0001: /*
0002: * Licensed to the Apache Software Foundation (ASF) under one or more
0003: * contributor license agreements. See the NOTICE file distributed with
0004: * this work for additional information regarding copyright ownership.
0005: * The ASF licenses this file to You under the Apache License, Version 2.0
0006: * (the "License"); you may not use this file except in compliance with
0007: * the License. You may obtain a copy of the License at
0008: *
0009: * http://www.apache.org/licenses/LICENSE-2.0
0010: *
0011: * Unless required by applicable law or agreed to in writing, software
0012: * distributed under the License is distributed on an "AS IS" BASIS,
0013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014: * See the License for the specific language governing permissions and
0015: * limitations under the License.
0016: */
0017: /* Generated By:JavaCC: Do not edit this line. FilterParser.java */
0018:
0019: package org.apache.harmony.jndi.provider.ldap.parser;
0020:
0021: import java.io.FileInputStream;
0022: import java.io.FileNotFoundException;
0023: import java.util.ArrayList;
0024: import java.util.List;
0025: import java.io.StringReader;
0026: import org.apache.harmony.jndi.provider.ldap.Filter;
0027: import org.apache.harmony.jndi.internal.parser.AttributeTypeAndValuePair;
0028: import org.apache.harmony.jndi.provider.ldap.Filter.MatchingRuleAssertion;
0029: import org.apache.harmony.jndi.provider.ldap.Filter.SubstringFilter;
0030: import org.apache.harmony.jndi.provider.ldap.asn1.Utils;
0031:
0032: /**
0033: * Ldap filter parser which parse the string representation of Ldap filters to
0034: * instance of org.apache.harmony.jndi.provider.ldap.filter.Filter according
0035: * RFC2254. And It also support parse variables of the form {i}.
0036: *
0037: * @see org.apache.harmony.jndi.provider.ldap.Filter
0038: * @see javax.naming.directory.DirContext#search(javax.naming.Name, String,
0039: * Object[], javax.naming.directory.SearchControls)
0040: */
0041: public class FilterParser implements FilterParserConstants {
0042:
0043: public static void main(String args[]) throws ParseException,
0044: FileNotFoundException {
0045: FilterParser parser = new FilterParser(new FileInputStream(
0046: "parser.filter.test"));
0047: // FilterParser parser = new FilterParser(System.in);
0048: //System.out.println(parser.value());
0049: parser.test();
0050: }
0051:
0052: private Object[] args;
0053:
0054: private boolean isEndEOF = false;
0055:
0056: public FilterParser(String filter) {
0057: this (new StringReader(filter));
0058: isEndEOF = true;
0059: }
0060:
0061: public Object[] getArgs() {
0062: return args;
0063: }
0064:
0065: public void setArgs(Object[] args) {
0066: this .args = args;
0067: }
0068:
0069: private String getArgAttrValue(String index) {
0070: int i = Integer.valueOf(index).intValue();
0071: if (args == null || args.length <= i || args[i] == null) {
0072: throw new IllegalArgumentException();
0073: }
0074:
0075: return (String) args[i];
0076: }
0077:
0078: private String getArgValue(String index) {
0079: int i = Integer.valueOf(index).intValue();
0080: if (args == null || args.length <= i || args[i] == null) {
0081: throw new IllegalArgumentException();
0082: }
0083: if (args[i] instanceof String) {
0084: return (String) args[i];
0085: }
0086:
0087: //FIXME:
0088: throw new RuntimeException(
0089: "Convert value to corresponding java type.");
0090: }
0091:
0092: private String convertToUtf8Char(String s) {
0093: byte[] bs = new byte[] { (byte) Integer.parseInt(s, 16) };
0094: return Utils.getString(bs);
0095: }
0096:
0097: private Filter parseSubstring(String des, List list) {
0098: Filter filter = null;
0099: if (list.size() == 1) {
0100: if (list.get(0).equals("*")) {
0101: filter = new Filter(Filter.PRESENT_FILTER);
0102: filter.setValue(des);
0103: } else {
0104: filter = new Filter(Filter.EQUALITY_MATCH_FILTER);
0105: filter.setValue(new AttributeTypeAndValuePair(des, list
0106: .get(0)));
0107: }
0108: } else {
0109: String initial = null;
0110: String any = "";
0111: String end = null;
0112: if (list.get(0).equals("*")) {
0113: any = "*";
0114: } else {
0115: initial = (String) list.get(0);
0116: }
0117:
0118: for (int i = 1; i < list.size(); ++i) {
0119: String value = (String) list.get(i);
0120: if (i == list.size() - 1 && !value.equals("*")) {
0121: end = value;
0122: } else {
0123: any += value;
0124: }
0125: }
0126: filter = new Filter(Filter.SUBSTRINGS_FILTER);
0127: SubstringFilter substring = new SubstringFilter(des);
0128: if (initial != null) {
0129: substring.addInitial(initial);
0130: }
0131:
0132: substring.addAny(any);
0133:
0134: if (end != null) {
0135: substring.addFinal(end);
0136: }
0137: filter.setValue(substring);
0138: }
0139:
0140: return filter;
0141: }
0142:
0143: final public String option() throws ParseException {
0144: StringBuilder value = new StringBuilder();
0145: Token t;
0146: t = jj_consume_token(SEMI);
0147: value.append(t.image);
0148: label_1: while (true) {
0149: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0150: case HEX_CHAR:
0151: t = jj_consume_token(HEX_CHAR);
0152: value.append(t.image);
0153: break;
0154: case NOHEX_CHAR:
0155: t = jj_consume_token(NOHEX_CHAR);
0156: value.append(t.image);
0157: break;
0158: case ZERO:
0159: t = jj_consume_token(ZERO);
0160: value.append(t.image);
0161: break;
0162: case DIGIT:
0163: t = jj_consume_token(DIGIT);
0164: value.append(t.image);
0165: break;
0166: case HYPHEN:
0167: t = jj_consume_token(HYPHEN);
0168: value.append(t.image);
0169: break;
0170: default:
0171: jj_la1[0] = jj_gen;
0172: jj_consume_token(-1);
0173: throw new ParseException();
0174: }
0175: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0176: case HEX_CHAR:
0177: case NOHEX_CHAR:
0178: case ZERO:
0179: case DIGIT:
0180: case HYPHEN:
0181: ;
0182: break;
0183: default:
0184: jj_la1[1] = jj_gen;
0185: break label_1;
0186: }
0187: }
0188: {
0189: if (true)
0190: return value.toString();
0191: }
0192: throw new Error("Missing return statement in function");
0193: }
0194:
0195: final public String number() throws ParseException {
0196: StringBuilder value = new StringBuilder();
0197: Token t;
0198: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0199: case ZERO:
0200: t = jj_consume_token(ZERO);
0201: value.append(t.image);
0202: break;
0203: case DIGIT:
0204: t = jj_consume_token(DIGIT);
0205: value.append(t.image);
0206: label_2: while (true) {
0207: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0208: case ZERO:
0209: case DIGIT:
0210: ;
0211: break;
0212: default:
0213: jj_la1[2] = jj_gen;
0214: break label_2;
0215: }
0216: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0217: case ZERO:
0218: t = jj_consume_token(ZERO);
0219: value.append(t.image);
0220: break;
0221: case DIGIT:
0222: t = jj_consume_token(DIGIT);
0223: value.append(t.image);
0224: break;
0225: default:
0226: jj_la1[3] = jj_gen;
0227: jj_consume_token(-1);
0228: throw new ParseException();
0229: }
0230: }
0231: break;
0232: default:
0233: jj_la1[4] = jj_gen;
0234: jj_consume_token(-1);
0235: throw new ParseException();
0236: }
0237: {
0238: if (true)
0239: return value.toString();
0240: }
0241: throw new Error("Missing return statement in function");
0242: }
0243:
0244: final public String oid() throws ParseException {
0245: StringBuilder value = new StringBuilder();
0246: String number = null;
0247: Token t = null;
0248: number = number();
0249: value.append(number);
0250: label_3: while (true) {
0251: t = jj_consume_token(PERIOD);
0252: value.append(t.image);
0253: number = number();
0254: value.append(number);
0255: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0256: case PERIOD:
0257: ;
0258: break;
0259: default:
0260: jj_la1[5] = jj_gen;
0261: break label_3;
0262: }
0263: }
0264: {
0265: if (true)
0266: return value.toString();
0267: }
0268: throw new Error("Missing return statement in function");
0269: }
0270:
0271: final public String matchingrule() throws ParseException {
0272: String value = null;
0273: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0274: case ZERO:
0275: case DIGIT:
0276: value = oid();
0277: break;
0278: case HEX_CHAR:
0279: case NOHEX_CHAR:
0280: case LBRACE:
0281: value = attrType();
0282: break;
0283: default:
0284: jj_la1[6] = jj_gen;
0285: jj_consume_token(-1);
0286: throw new ParseException();
0287: }
0288: {
0289: if (true)
0290: return value;
0291: }
0292: throw new Error("Missing return statement in function");
0293: }
0294:
0295: final public String argument() throws ParseException {
0296: String num = null;
0297: jj_consume_token(LBRACE);
0298: num = number();
0299: jj_consume_token(RBRACE);
0300: {
0301: if (true)
0302: return getArgAttrValue(num);
0303: }
0304: throw new Error("Missing return statement in function");
0305: }
0306:
0307: final public String attrType() throws ParseException {
0308: StringBuilder value = new StringBuilder();
0309: String arg;
0310: Token t;
0311: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0312: case HEX_CHAR:
0313: t = jj_consume_token(HEX_CHAR);
0314: value.append(t.image);
0315: break;
0316: case NOHEX_CHAR:
0317: t = jj_consume_token(NOHEX_CHAR);
0318: value.append(t.image);
0319: break;
0320: case LBRACE:
0321: arg = argument();
0322: value.append(arg);
0323: break;
0324: default:
0325: jj_la1[7] = jj_gen;
0326: jj_consume_token(-1);
0327: throw new ParseException();
0328: }
0329: label_4: while (true) {
0330: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0331: case HEX_CHAR:
0332: case NOHEX_CHAR:
0333: case LBRACE:
0334: case ZERO:
0335: case DIGIT:
0336: case HYPHEN:
0337: ;
0338: break;
0339: default:
0340: jj_la1[8] = jj_gen;
0341: break label_4;
0342: }
0343: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0344: case HEX_CHAR:
0345: case NOHEX_CHAR:
0346: case ZERO:
0347: case DIGIT:
0348: case HYPHEN:
0349: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0350: case HEX_CHAR:
0351: t = jj_consume_token(HEX_CHAR);
0352: break;
0353: case NOHEX_CHAR:
0354: t = jj_consume_token(NOHEX_CHAR);
0355: break;
0356: case ZERO:
0357: t = jj_consume_token(ZERO);
0358: break;
0359: case DIGIT:
0360: t = jj_consume_token(DIGIT);
0361: break;
0362: case HYPHEN:
0363: t = jj_consume_token(HYPHEN);
0364: break;
0365: default:
0366: jj_la1[9] = jj_gen;
0367: jj_consume_token(-1);
0368: throw new ParseException();
0369: }
0370: value.append(t.image);
0371: break;
0372: case LBRACE:
0373: arg = argument();
0374: value.append(arg);
0375: break;
0376: default:
0377: jj_la1[10] = jj_gen;
0378: jj_consume_token(-1);
0379: throw new ParseException();
0380: }
0381: }
0382: {
0383: if (true)
0384: return value.toString();
0385: }
0386: throw new Error("Missing return statement in function");
0387: }
0388:
0389: final public String attrDescr() throws ParseException {
0390: String type;
0391: type = attrType();
0392: label_5: while (true) {
0393: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0394: case SEMI:
0395: ;
0396: break;
0397: default:
0398: jj_la1[11] = jj_gen;
0399: break label_5;
0400: }
0401: option();
0402: }
0403: {
0404: if (true)
0405: return type;
0406: }
0407: throw new Error("Missing return statement in function");
0408: }
0409:
0410: final public void test() throws ParseException {
0411: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0412: case LPARENT:
0413: /*
0414: * initial args for test, so there should not be args index larger than
0415: * 49 in test case
0416: */
0417: args = new Object[20];
0418: for (int i = 0; i < args.length; i++) {
0419: args[i] = "{" + i + "}";
0420: }
0421: parse();
0422: jj_consume_token(24);
0423: test();
0424: break;
0425: default:
0426: jj_la1[12] = jj_gen;
0427: if (jj_2_1(2)) {
0428: jj_consume_token(24);
0429: } else {
0430: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0431: case 24:
0432: jj_consume_token(24);
0433: jj_consume_token(0);
0434: break;
0435: case 0:
0436: jj_consume_token(0);
0437: break;
0438: default:
0439: jj_la1[13] = jj_gen;
0440: jj_consume_token(-1);
0441: throw new ParseException();
0442: }
0443: }
0444: }
0445: }
0446:
0447: // FIXME: get string representation of AttributeValue, then use Rdn.unescapeValue(String) to get value
0448: final public String value() throws ParseException {
0449: StringBuilder value = new StringBuilder();
0450: String hexValue = null;
0451: Token t = null;
0452: ;
0453: String arg = null;
0454: label_6: while (true) {
0455: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0456: case NOHEX_CHAR:
0457: t = jj_consume_token(NOHEX_CHAR);
0458: value.append(t.image);
0459: break;
0460: case HEX_CHAR:
0461: t = jj_consume_token(HEX_CHAR);
0462: value.append(t.image);
0463: break;
0464: case ZERO:
0465: t = jj_consume_token(ZERO);
0466: value.append(t.image);
0467: break;
0468: case DIGIT:
0469: t = jj_consume_token(DIGIT);
0470: value.append(t.image);
0471: break;
0472: case HYPHEN:
0473: t = jj_consume_token(HYPHEN);
0474: value.append(t.image);
0475: break;
0476: case COLON:
0477: t = jj_consume_token(COLON);
0478: value.append(t.image);
0479: break;
0480: case BACKSLASH:
0481: hexValue = backslashValue();
0482: value.append(hexValue);
0483: break;
0484: case LBRACE:
0485: arg = argument();
0486: value.append(arg);
0487: break;
0488: case CHAR:
0489: t = jj_consume_token(CHAR);
0490: value.append(t.image);
0491: break;
0492: default:
0493: jj_la1[14] = jj_gen;
0494: jj_consume_token(-1);
0495: throw new ParseException();
0496: }
0497: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0498: case HEX_CHAR:
0499: case NOHEX_CHAR:
0500: case LBRACE:
0501: case ZERO:
0502: case COLON:
0503: case DIGIT:
0504: case HYPHEN:
0505: case BACKSLASH:
0506: case CHAR:
0507: ;
0508: break;
0509: default:
0510: jj_la1[15] = jj_gen;
0511: break label_6;
0512: }
0513: }
0514: {
0515: if (true)
0516: return value.toString();
0517: }
0518: throw new Error("Missing return statement in function");
0519: }
0520:
0521: final public String backslashValue() throws ParseException {
0522: String value;
0523: jj_consume_token(BACKSLASH);
0524: value = hexDigit();
0525: {
0526: if (true)
0527: return convertToUtf8Char(value);
0528: }
0529: throw new Error("Missing return statement in function");
0530: }
0531:
0532: final public String hexDigit() throws ParseException {
0533: String value;
0534: Token t;
0535: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0536: case HEX_CHAR:
0537: t = jj_consume_token(HEX_CHAR);
0538: break;
0539: case DIGIT:
0540: t = jj_consume_token(DIGIT);
0541: break;
0542: case ZERO:
0543: t = jj_consume_token(ZERO);
0544: break;
0545: default:
0546: jj_la1[16] = jj_gen;
0547: jj_consume_token(-1);
0548: throw new ParseException();
0549: }
0550: value = t.image;
0551: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0552: case HEX_CHAR:
0553: t = jj_consume_token(HEX_CHAR);
0554: break;
0555: case DIGIT:
0556: t = jj_consume_token(DIGIT);
0557: break;
0558: case ZERO:
0559: t = jj_consume_token(ZERO);
0560: break;
0561: default:
0562: jj_la1[17] = jj_gen;
0563: jj_consume_token(-1);
0564: throw new ParseException();
0565: }
0566: value += t.image;
0567: {
0568: if (true)
0569: return value;
0570: }
0571: throw new Error("Missing return statement in function");
0572: }
0573:
0574: final public Filter parse() throws ParseException {
0575: Filter filter = null;
0576: Filter temp = null;
0577: jj_consume_token(LPARENT);
0578: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0579: case AND:
0580: jj_consume_token(AND);
0581: filter = new Filter(Filter.AND_FILTER);
0582: temp = parse();
0583: filter.addChild(temp);
0584: temp = parse();
0585: filter.addChild(temp);
0586: label_7: while (true) {
0587: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0588: case LPARENT:
0589: ;
0590: break;
0591: default:
0592: jj_la1[18] = jj_gen;
0593: break label_7;
0594: }
0595: temp = parse();
0596: filter.addChild(temp);
0597: }
0598: break;
0599: case OR:
0600: jj_consume_token(OR);
0601: filter = new Filter(Filter.OR_FILTER);
0602: temp = parse();
0603: filter.addChild(temp);
0604: temp = parse();
0605: filter.addChild(temp);
0606: label_8: while (true) {
0607: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0608: case LPARENT:
0609: ;
0610: break;
0611: default:
0612: jj_la1[19] = jj_gen;
0613: break label_8;
0614: }
0615: temp = parse();
0616: filter.addChild(temp);
0617: }
0618: break;
0619: case NOT:
0620: jj_consume_token(NOT);
0621: filter = new Filter(Filter.NOT_FILTER);
0622: temp = parse();
0623: filter.setValue(temp);
0624: break;
0625: case COLON_DN:
0626: case HEX_CHAR:
0627: case NOHEX_CHAR:
0628: case LBRACE:
0629: case COLON:
0630: filter = item();
0631: break;
0632: default:
0633: jj_la1[20] = jj_gen;
0634: jj_consume_token(-1);
0635: throw new ParseException();
0636: }
0637: jj_consume_token(RPARENT);
0638: {
0639: if (true)
0640: return filter;
0641: }
0642: throw new Error("Missing return statement in function");
0643: }
0644:
0645: final public void eof() throws ParseException {
0646: jj_consume_token(0);
0647: }
0648:
0649: final public Filter item() throws ParseException {
0650: Filter filter = null;
0651: String value = null;
0652: String des = null;
0653: String temp = null;
0654: List list = new ArrayList();
0655: SubstringFilter substring = null;
0656: MatchingRuleAssertion rule = null;
0657: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0658: case HEX_CHAR:
0659: case NOHEX_CHAR:
0660: case LBRACE:
0661: des = attrDescr();
0662: if (jj_2_2(2)) {
0663: jj_consume_token(APPROX);
0664: jj_consume_token(EQUAL);
0665: value = value();
0666: filter = new Filter(Filter.APPROX_MATCH_FILTER);
0667: filter.setValue(new AttributeTypeAndValuePair(des,
0668: value));
0669: } else {
0670: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0671: case GREATER:
0672: jj_consume_token(GREATER);
0673: jj_consume_token(EQUAL);
0674: value = value();
0675: filter = new Filter(Filter.GREATER_OR_EQUAL_FILTER);
0676: filter.setValue(new AttributeTypeAndValuePair(des,
0677: value));
0678: break;
0679: case LESS:
0680: jj_consume_token(LESS);
0681: jj_consume_token(EQUAL);
0682: value = value();
0683: filter = new Filter(Filter.LESS_OR_EQUAL_FILTER);
0684: filter.setValue(new AttributeTypeAndValuePair(des,
0685: value));
0686: break;
0687: default:
0688: jj_la1[22] = jj_gen;
0689: if (jj_2_3(3)) {
0690: jj_consume_token(EQUAL);
0691: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0692: case ASTERISK:
0693: asterisk_start(list);
0694: break;
0695: case HEX_CHAR:
0696: case NOHEX_CHAR:
0697: case LBRACE:
0698: case ZERO:
0699: case COLON:
0700: case DIGIT:
0701: case HYPHEN:
0702: case BACKSLASH:
0703: case CHAR:
0704: value_start(list);
0705: break;
0706: default:
0707: jj_la1[21] = jj_gen;
0708: jj_consume_token(-1);
0709: throw new ParseException();
0710: }
0711: filter = parseSubstring(des, list);
0712: } else {
0713: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0714: case COLON_DN:
0715: case COLON:
0716: rule = extensible_1(des);
0717: filter = new Filter(
0718: Filter.EXTENSIBLE_MATCH_FILTER);
0719: filter.setValue(rule);
0720: break;
0721: default:
0722: jj_la1[23] = jj_gen;
0723: jj_consume_token(-1);
0724: throw new ParseException();
0725: }
0726: }
0727: }
0728: }
0729: break;
0730: case COLON_DN:
0731: case COLON:
0732: rule = extensible_2();
0733: filter = new Filter(Filter.EXTENSIBLE_MATCH_FILTER);
0734: filter.setValue(rule);
0735: break;
0736: default:
0737: jj_la1[24] = jj_gen;
0738: jj_consume_token(-1);
0739: throw new ParseException();
0740: }
0741: {
0742: if (true)
0743: return filter;
0744: }
0745: throw new Error("Missing return statement in function");
0746: }
0747:
0748: final public void asterisk_start(List list) throws ParseException {
0749: jj_consume_token(ASTERISK);
0750: list.add("*");
0751: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0752: case HEX_CHAR:
0753: case NOHEX_CHAR:
0754: case LBRACE:
0755: case ZERO:
0756: case COLON:
0757: case DIGIT:
0758: case HYPHEN:
0759: case BACKSLASH:
0760: case CHAR:
0761: value_start(list);
0762: break;
0763: default:
0764: jj_la1[25] = jj_gen;
0765: ;
0766: }
0767: }
0768:
0769: final public void value_start(List list) throws ParseException {
0770: String value;
0771: value = value();
0772: list.add(value);
0773: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0774: case ASTERISK:
0775: asterisk_start(list);
0776: break;
0777: default:
0778: jj_la1[26] = jj_gen;
0779: ;
0780: }
0781: }
0782:
0783: final public String final_part() throws ParseException {
0784: String value;
0785: value = value();
0786: {
0787: if (true)
0788: return value;
0789: }
0790: throw new Error("Missing return statement in function");
0791: }
0792:
0793: final public String tail_part() throws ParseException {
0794: String value;
0795: String temp;
0796: value = any_part();
0797: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0798: case HEX_CHAR:
0799: case NOHEX_CHAR:
0800: case LBRACE:
0801: case ZERO:
0802: case COLON:
0803: case DIGIT:
0804: case HYPHEN:
0805: case BACKSLASH:
0806: case CHAR:
0807: temp = final_part();
0808: value = value + temp;
0809: break;
0810: default:
0811: jj_la1[27] = jj_gen;
0812: ;
0813: }
0814: {
0815: if (true)
0816: return value;
0817: }
0818: throw new Error("Missing return statement in function");
0819: }
0820:
0821: final public String any_part() throws ParseException {
0822: StringBuilder value = new StringBuilder();
0823: Token t;
0824: String temp;
0825: t = jj_consume_token(ASTERISK);
0826: value.append(t.image);
0827: label_9: while (true) {
0828: temp = value();
0829: value.append(temp);
0830: t = jj_consume_token(ASTERISK);
0831: value.append(t.image);
0832: if (jj_2_4(2)) {
0833: ;
0834: } else {
0835: break label_9;
0836: }
0837: }
0838: {
0839: if (true)
0840: return value.toString();
0841: }
0842: throw new Error("Missing return statement in function");
0843: }
0844:
0845: final public MatchingRuleAssertion extensible_1(String type)
0846: throws ParseException {
0847: MatchingRuleAssertion rule = new MatchingRuleAssertion();
0848: rule.setType(type);
0849: String value;
0850: if (jj_2_5(2)) {
0851: jj_consume_token(COLON_DN);
0852: rule.setDnAttributes(true);
0853: } else {
0854: ;
0855: }
0856: if (jj_2_6(2)) {
0857: jj_consume_token(COLON);
0858: value = oid();
0859: rule.setMatchingRule(value);
0860: } else {
0861: ;
0862: }
0863: jj_consume_token(COLON);
0864: jj_consume_token(EQUAL);
0865: value = value();
0866: rule.setMatchValue(value);
0867: {
0868: if (true)
0869: return rule;
0870: }
0871: throw new Error("Missing return statement in function");
0872: }
0873:
0874: final public MatchingRuleAssertion extensible_2()
0875: throws ParseException {
0876: MatchingRuleAssertion rule = new MatchingRuleAssertion();
0877: String value;
0878: if (jj_2_7(2)) {
0879: jj_consume_token(COLON_DN);
0880: } else {
0881: ;
0882: }
0883: jj_consume_token(COLON);
0884: value = matchingrule();
0885: rule.setMatchingRule(value);
0886: jj_consume_token(COLON);
0887: jj_consume_token(EQUAL);
0888: value = value();
0889: rule.setMatchValue(value);
0890: {
0891: if (true)
0892: return rule;
0893: }
0894: throw new Error("Missing return statement in function");
0895: }
0896:
0897: final public void colon_oid() throws ParseException {
0898: jj_consume_token(COLON);
0899: oid();
0900: }
0901:
0902: final private boolean jj_2_1(int xla) {
0903: jj_la = xla;
0904: jj_lastpos = jj_scanpos = token;
0905: try {
0906: return !jj_3_1();
0907: } catch (LookaheadSuccess ls) {
0908: return true;
0909: } finally {
0910: jj_save(0, xla);
0911: }
0912: }
0913:
0914: final private boolean jj_2_2(int xla) {
0915: jj_la = xla;
0916: jj_lastpos = jj_scanpos = token;
0917: try {
0918: return !jj_3_2();
0919: } catch (LookaheadSuccess ls) {
0920: return true;
0921: } finally {
0922: jj_save(1, xla);
0923: }
0924: }
0925:
0926: final private boolean jj_2_3(int xla) {
0927: jj_la = xla;
0928: jj_lastpos = jj_scanpos = token;
0929: try {
0930: return !jj_3_3();
0931: } catch (LookaheadSuccess ls) {
0932: return true;
0933: } finally {
0934: jj_save(2, xla);
0935: }
0936: }
0937:
0938: final private boolean jj_2_4(int xla) {
0939: jj_la = xla;
0940: jj_lastpos = jj_scanpos = token;
0941: try {
0942: return !jj_3_4();
0943: } catch (LookaheadSuccess ls) {
0944: return true;
0945: } finally {
0946: jj_save(3, xla);
0947: }
0948: }
0949:
0950: final private boolean jj_2_5(int xla) {
0951: jj_la = xla;
0952: jj_lastpos = jj_scanpos = token;
0953: try {
0954: return !jj_3_5();
0955: } catch (LookaheadSuccess ls) {
0956: return true;
0957: } finally {
0958: jj_save(4, xla);
0959: }
0960: }
0961:
0962: final private boolean jj_2_6(int xla) {
0963: jj_la = xla;
0964: jj_lastpos = jj_scanpos = token;
0965: try {
0966: return !jj_3_6();
0967: } catch (LookaheadSuccess ls) {
0968: return true;
0969: } finally {
0970: jj_save(5, xla);
0971: }
0972: }
0973:
0974: final private boolean jj_2_7(int xla) {
0975: jj_la = xla;
0976: jj_lastpos = jj_scanpos = token;
0977: try {
0978: return !jj_3_7();
0979: } catch (LookaheadSuccess ls) {
0980: return true;
0981: } finally {
0982: jj_save(6, xla);
0983: }
0984: }
0985:
0986: final private boolean jj_3R_12() {
0987: Token xsp;
0988: if (jj_3R_16())
0989: return true;
0990: while (true) {
0991: xsp = jj_scanpos;
0992: if (jj_3R_16()) {
0993: jj_scanpos = xsp;
0994: break;
0995: }
0996: }
0997: return false;
0998: }
0999:
1000: final private boolean jj_3R_15() {
1001: if (jj_3R_12())
1002: return true;
1003: Token xsp;
1004: xsp = jj_scanpos;
1005: if (jj_3R_19())
1006: jj_scanpos = xsp;
1007: return false;
1008: }
1009:
1010: final private boolean jj_3R_32() {
1011: if (jj_scan_token(LBRACE))
1012: return true;
1013: if (jj_3R_17())
1014: return true;
1015: return false;
1016: }
1017:
1018: final private boolean jj_3_6() {
1019: if (jj_scan_token(COLON))
1020: return true;
1021: if (jj_3R_13())
1022: return true;
1023: return false;
1024: }
1025:
1026: final private boolean jj_3_5() {
1027: if (jj_scan_token(COLON_DN))
1028: return true;
1029: return false;
1030: }
1031:
1032: final private boolean jj_3R_14() {
1033: if (jj_scan_token(ASTERISK))
1034: return true;
1035: Token xsp;
1036: xsp = jj_scanpos;
1037: if (jj_3R_18())
1038: jj_scanpos = xsp;
1039: return false;
1040: }
1041:
1042: final private boolean jj_3R_19() {
1043: if (jj_3R_14())
1044: return true;
1045: return false;
1046: }
1047:
1048: final private boolean jj_3R_33() {
1049: Token xsp;
1050: xsp = jj_scanpos;
1051: if (jj_scan_token(2)) {
1052: jj_scanpos = xsp;
1053: if (jj_scan_token(18)) {
1054: jj_scanpos = xsp;
1055: if (jj_scan_token(11))
1056: return true;
1057: }
1058: }
1059: return false;
1060: }
1061:
1062: final private boolean jj_3_3() {
1063: if (jj_scan_token(EQUAL))
1064: return true;
1065: Token xsp;
1066: xsp = jj_scanpos;
1067: if (jj_3R_10()) {
1068: jj_scanpos = xsp;
1069: if (jj_3R_11())
1070: return true;
1071: }
1072: return false;
1073: }
1074:
1075: final private boolean jj_3R_11() {
1076: if (jj_3R_15())
1077: return true;
1078: return false;
1079: }
1080:
1081: final private boolean jj_3_4() {
1082: if (jj_3R_12())
1083: return true;
1084: if (jj_scan_token(ASTERISK))
1085: return true;
1086: return false;
1087: }
1088:
1089: final private boolean jj_3R_13() {
1090: if (jj_3R_17())
1091: return true;
1092: return false;
1093: }
1094:
1095: final private boolean jj_3R_31() {
1096: if (jj_scan_token(BACKSLASH))
1097: return true;
1098: if (jj_3R_33())
1099: return true;
1100: return false;
1101: }
1102:
1103: final private boolean jj_3R_18() {
1104: if (jj_3R_15())
1105: return true;
1106: return false;
1107: }
1108:
1109: final private boolean jj_3_2() {
1110: if (jj_scan_token(APPROX))
1111: return true;
1112: if (jj_scan_token(EQUAL))
1113: return true;
1114: return false;
1115: }
1116:
1117: final private boolean jj_3R_28() {
1118: if (jj_scan_token(CHAR))
1119: return true;
1120: return false;
1121: }
1122:
1123: final private boolean jj_3_1() {
1124: if (jj_scan_token(24))
1125: return true;
1126: return false;
1127: }
1128:
1129: final private boolean jj_3R_27() {
1130: if (jj_3R_32())
1131: return true;
1132: return false;
1133: }
1134:
1135: final private boolean jj_3R_30() {
1136: if (jj_scan_token(DIGIT))
1137: return true;
1138: return false;
1139: }
1140:
1141: final private boolean jj_3R_26() {
1142: if (jj_3R_31())
1143: return true;
1144: return false;
1145: }
1146:
1147: final private boolean jj_3R_25() {
1148: if (jj_scan_token(COLON))
1149: return true;
1150: return false;
1151: }
1152:
1153: final private boolean jj_3R_29() {
1154: if (jj_scan_token(ZERO))
1155: return true;
1156: return false;
1157: }
1158:
1159: final private boolean jj_3R_24() {
1160: if (jj_scan_token(HYPHEN))
1161: return true;
1162: return false;
1163: }
1164:
1165: final private boolean jj_3R_23() {
1166: if (jj_scan_token(DIGIT))
1167: return true;
1168: return false;
1169: }
1170:
1171: final private boolean jj_3R_17() {
1172: Token xsp;
1173: xsp = jj_scanpos;
1174: if (jj_3R_29()) {
1175: jj_scanpos = xsp;
1176: if (jj_3R_30())
1177: return true;
1178: }
1179: return false;
1180: }
1181:
1182: final private boolean jj_3R_22() {
1183: if (jj_scan_token(ZERO))
1184: return true;
1185: return false;
1186: }
1187:
1188: final private boolean jj_3R_21() {
1189: if (jj_scan_token(HEX_CHAR))
1190: return true;
1191: return false;
1192: }
1193:
1194: final private boolean jj_3R_10() {
1195: if (jj_3R_14())
1196: return true;
1197: return false;
1198: }
1199:
1200: final private boolean jj_3_7() {
1201: if (jj_scan_token(COLON_DN))
1202: return true;
1203: return false;
1204: }
1205:
1206: final private boolean jj_3R_20() {
1207: if (jj_scan_token(NOHEX_CHAR))
1208: return true;
1209: return false;
1210: }
1211:
1212: final private boolean jj_3R_16() {
1213: Token xsp;
1214: xsp = jj_scanpos;
1215: if (jj_3R_20()) {
1216: jj_scanpos = xsp;
1217: if (jj_3R_21()) {
1218: jj_scanpos = xsp;
1219: if (jj_3R_22()) {
1220: jj_scanpos = xsp;
1221: if (jj_3R_23()) {
1222: jj_scanpos = xsp;
1223: if (jj_3R_24()) {
1224: jj_scanpos = xsp;
1225: if (jj_3R_25()) {
1226: jj_scanpos = xsp;
1227: if (jj_3R_26()) {
1228: jj_scanpos = xsp;
1229: if (jj_3R_27()) {
1230: jj_scanpos = xsp;
1231: if (jj_3R_28())
1232: return true;
1233: }
1234: }
1235: }
1236: }
1237: }
1238: }
1239: }
1240: }
1241: return false;
1242: }
1243:
1244: public FilterParserTokenManager token_source;
1245: SimpleCharStream jj_input_stream;
1246: public Token token, jj_nt;
1247: private int jj_ntk;
1248: private Token jj_scanpos, jj_lastpos;
1249: private int jj_la;
1250: public boolean lookingAhead = false;
1251: private boolean jj_semLA;
1252: private int jj_gen;
1253: final private int[] jj_la1 = new int[28];
1254: static private int[] jj_la1_0;
1255: static {
1256: jj_la1_0();
1257: }
1258:
1259: private static void jj_la1_0() {
1260: jj_la1_0 = new int[] { 0xc080c, 0xc080c, 0x40800, 0x40800,
1261: 0x40800, 0x100000, 0x4084c, 0x4c, 0xc084c, 0xc080c,
1262: 0xc084c, 0x400000, 0x10, 0x1000001, 0xac184c, 0xac184c,
1263: 0x40804, 0x40804, 0x10, 0x10, 0x174e, 0xae184c, 0xc000,
1264: 0x1002, 0x104e, 0xac184c, 0x20000, 0xac184c, };
1265: }
1266:
1267: final private JJCalls[] jj_2_rtns = new JJCalls[7];
1268: private boolean jj_rescan = false;
1269: private int jj_gc = 0;
1270:
1271: public FilterParser(java.io.InputStream stream) {
1272: jj_input_stream = new SimpleCharStream(stream, 1, 1);
1273: token_source = new FilterParserTokenManager(jj_input_stream);
1274: token = new Token();
1275: jj_ntk = -1;
1276: jj_gen = 0;
1277: for (int i = 0; i < 28; i++)
1278: jj_la1[i] = -1;
1279: for (int i = 0; i < jj_2_rtns.length; i++)
1280: jj_2_rtns[i] = new JJCalls();
1281: }
1282:
1283: public void ReInit(java.io.InputStream stream) {
1284: jj_input_stream.ReInit(stream, 1, 1);
1285: token_source.ReInit(jj_input_stream);
1286: token = new Token();
1287: jj_ntk = -1;
1288: jj_gen = 0;
1289: for (int i = 0; i < 28; i++)
1290: jj_la1[i] = -1;
1291: for (int i = 0; i < jj_2_rtns.length; i++)
1292: jj_2_rtns[i] = new JJCalls();
1293: }
1294:
1295: public FilterParser(java.io.Reader stream) {
1296: jj_input_stream = new SimpleCharStream(stream, 1, 1);
1297: token_source = new FilterParserTokenManager(jj_input_stream);
1298: token = new Token();
1299: jj_ntk = -1;
1300: jj_gen = 0;
1301: for (int i = 0; i < 28; i++)
1302: jj_la1[i] = -1;
1303: for (int i = 0; i < jj_2_rtns.length; i++)
1304: jj_2_rtns[i] = new JJCalls();
1305: }
1306:
1307: public void ReInit(java.io.Reader stream) {
1308: jj_input_stream.ReInit(stream, 1, 1);
1309: token_source.ReInit(jj_input_stream);
1310: token = new Token();
1311: jj_ntk = -1;
1312: jj_gen = 0;
1313: for (int i = 0; i < 28; i++)
1314: jj_la1[i] = -1;
1315: for (int i = 0; i < jj_2_rtns.length; i++)
1316: jj_2_rtns[i] = new JJCalls();
1317: }
1318:
1319: public FilterParser(FilterParserTokenManager tm) {
1320: token_source = tm;
1321: token = new Token();
1322: jj_ntk = -1;
1323: jj_gen = 0;
1324: for (int i = 0; i < 28; i++)
1325: jj_la1[i] = -1;
1326: for (int i = 0; i < jj_2_rtns.length; i++)
1327: jj_2_rtns[i] = new JJCalls();
1328: }
1329:
1330: public void ReInit(FilterParserTokenManager tm) {
1331: token_source = tm;
1332: token = new Token();
1333: jj_ntk = -1;
1334: jj_gen = 0;
1335: for (int i = 0; i < 28; i++)
1336: jj_la1[i] = -1;
1337: for (int i = 0; i < jj_2_rtns.length; i++)
1338: jj_2_rtns[i] = new JJCalls();
1339: }
1340:
1341: final private Token jj_consume_token(int kind)
1342: throws ParseException {
1343: Token oldToken;
1344: if ((oldToken = token).next != null)
1345: token = token.next;
1346: else
1347: token = token.next = token_source.getNextToken();
1348: jj_ntk = -1;
1349: if (token.kind == kind) {
1350: jj_gen++;
1351: if (++jj_gc > 100) {
1352: jj_gc = 0;
1353: for (int i = 0; i < jj_2_rtns.length; i++) {
1354: JJCalls c = jj_2_rtns[i];
1355: while (c != null) {
1356: if (c.gen < jj_gen)
1357: c.first = null;
1358: c = c.next;
1359: }
1360: }
1361: }
1362: return token;
1363: }
1364: token = oldToken;
1365: jj_kind = kind;
1366: throw generateParseException();
1367: }
1368:
1369: static private final class LookaheadSuccess extends java.lang.Error {
1370: }
1371:
1372: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
1373:
1374: final private boolean jj_scan_token(int kind) {
1375: if (jj_scanpos == jj_lastpos) {
1376: jj_la--;
1377: if (jj_scanpos.next == null) {
1378: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
1379: .getNextToken();
1380: } else {
1381: jj_lastpos = jj_scanpos = jj_scanpos.next;
1382: }
1383: } else {
1384: jj_scanpos = jj_scanpos.next;
1385: }
1386: if (jj_rescan) {
1387: int i = 0;
1388: Token tok = token;
1389: while (tok != null && tok != jj_scanpos) {
1390: i++;
1391: tok = tok.next;
1392: }
1393: if (tok != null)
1394: jj_add_error_token(kind, i);
1395: }
1396: if (jj_scanpos.kind != kind)
1397: return true;
1398: if (jj_la == 0 && jj_scanpos == jj_lastpos)
1399: throw jj_ls;
1400: return false;
1401: }
1402:
1403: final public Token getNextToken() {
1404: if (token.next != null)
1405: token = token.next;
1406: else
1407: token = token.next = token_source.getNextToken();
1408: jj_ntk = -1;
1409: jj_gen++;
1410: return token;
1411: }
1412:
1413: final public Token getToken(int index) {
1414: Token t = lookingAhead ? jj_scanpos : token;
1415: for (int i = 0; i < index; i++) {
1416: if (t.next != null)
1417: t = t.next;
1418: else
1419: t = t.next = token_source.getNextToken();
1420: }
1421: return t;
1422: }
1423:
1424: final private int jj_ntk() {
1425: if ((jj_nt = token.next) == null)
1426: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
1427: else
1428: return (jj_ntk = jj_nt.kind);
1429: }
1430:
1431: private java.util.Vector jj_expentries = new java.util.Vector();
1432: private int[] jj_expentry;
1433: private int jj_kind = -1;
1434: private int[] jj_lasttokens = new int[100];
1435: private int jj_endpos;
1436:
1437: private void jj_add_error_token(int kind, int pos) {
1438: if (pos >= 100)
1439: return;
1440: if (pos == jj_endpos + 1) {
1441: jj_lasttokens[jj_endpos++] = kind;
1442: } else if (jj_endpos != 0) {
1443: jj_expentry = new int[jj_endpos];
1444: for (int i = 0; i < jj_endpos; i++) {
1445: jj_expentry[i] = jj_lasttokens[i];
1446: }
1447: boolean exists = false;
1448: for (java.util.Enumeration e = jj_expentries.elements(); e
1449: .hasMoreElements();) {
1450: int[] oldentry = (int[]) (e.nextElement());
1451: if (oldentry.length == jj_expentry.length) {
1452: exists = true;
1453: for (int i = 0; i < jj_expentry.length; i++) {
1454: if (oldentry[i] != jj_expentry[i]) {
1455: exists = false;
1456: break;
1457: }
1458: }
1459: if (exists)
1460: break;
1461: }
1462: }
1463: if (!exists)
1464: jj_expentries.addElement(jj_expentry);
1465: if (pos != 0)
1466: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1467: }
1468: }
1469:
1470: public ParseException generateParseException() {
1471: jj_expentries.removeAllElements();
1472: boolean[] la1tokens = new boolean[25];
1473: for (int i = 0; i < 25; i++) {
1474: la1tokens[i] = false;
1475: }
1476: if (jj_kind >= 0) {
1477: la1tokens[jj_kind] = true;
1478: jj_kind = -1;
1479: }
1480: for (int i = 0; i < 28; i++) {
1481: if (jj_la1[i] == jj_gen) {
1482: for (int j = 0; j < 32; j++) {
1483: if ((jj_la1_0[i] & (1 << j)) != 0) {
1484: la1tokens[j] = true;
1485: }
1486: }
1487: }
1488: }
1489: for (int i = 0; i < 25; i++) {
1490: if (la1tokens[i]) {
1491: jj_expentry = new int[1];
1492: jj_expentry[0] = i;
1493: jj_expentries.addElement(jj_expentry);
1494: }
1495: }
1496: jj_endpos = 0;
1497: jj_rescan_token();
1498: jj_add_error_token(0, 0);
1499: int[][] exptokseq = new int[jj_expentries.size()][];
1500: for (int i = 0; i < jj_expentries.size(); i++) {
1501: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
1502: }
1503: return new ParseException(token, exptokseq, tokenImage);
1504: }
1505:
1506: final public void enable_tracing() {
1507: }
1508:
1509: final public void disable_tracing() {
1510: }
1511:
1512: final private void jj_rescan_token() {
1513: jj_rescan = true;
1514: for (int i = 0; i < 7; i++) {
1515: JJCalls p = jj_2_rtns[i];
1516: do {
1517: if (p.gen > jj_gen) {
1518: jj_la = p.arg;
1519: jj_lastpos = jj_scanpos = p.first;
1520: switch (i) {
1521: case 0:
1522: jj_3_1();
1523: break;
1524: case 1:
1525: jj_3_2();
1526: break;
1527: case 2:
1528: jj_3_3();
1529: break;
1530: case 3:
1531: jj_3_4();
1532: break;
1533: case 4:
1534: jj_3_5();
1535: break;
1536: case 5:
1537: jj_3_6();
1538: break;
1539: case 6:
1540: jj_3_7();
1541: break;
1542: }
1543: }
1544: p = p.next;
1545: } while (p != null);
1546: }
1547: jj_rescan = false;
1548: }
1549:
1550: final private void jj_save(int index, int xla) {
1551: JJCalls p = jj_2_rtns[index];
1552: while (p.gen > jj_gen) {
1553: if (p.next == null) {
1554: p = p.next = new JJCalls();
1555: break;
1556: }
1557: p = p.next;
1558: }
1559: p.gen = jj_gen + xla - jj_la;
1560: p.first = token;
1561: p.arg = xla;
1562: }
1563:
1564: static final class JJCalls {
1565: int gen;
1566: Token first;
1567: int arg;
1568: JJCalls next;
1569: }
1570:
1571: }
|