public BackRefNode(final int backRef, final ScanEnvironment env) { this.backRef = backRef; if (backRef <= env.numMem && env.memNodes[backRef] == null) { setRecursion(); /* /...(\1).../ */ } }
public void nextStateClass(final CCStateArg arg, final ScanEnvironment env) { if (arg.state == CCSTATE.RANGE) { throw new SyntaxException(ErrorMessages.ERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE); } if (arg.state == CCSTATE.VALUE && arg.type != CCVALTYPE.CLASS) { if (arg.type == CCVALTYPE.SB) { bs.set(arg.vs); } else if (arg.type == CCVALTYPE.CODE_POINT) { addCodeRange(env, arg.vs, arg.vs); } } arg.state = CCSTATE.VALUE; arg.type = CCVALTYPE.CLASS; }
public BackRefNode(int backRef, ScanEnvironment env) { this.backRef = backRef; if (backRef <= env.numMem && env.memNodes[backRef] == null) { setRecursion(); /* /...(\1).../ */ } }
public void addCodeRange(final ScanEnvironment env, final int from, final int to) { mbuf = CodeRangeBuffer.addCodeRange(mbuf, env, from, to); }
public void nextStateValue(final CCStateArg arg, final ScanEnvironment env) { switch(arg.state) { case VALUE: if (arg.type == CCVALTYPE.SB) { if (arg.vs > 0xff) { throw new ValueException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE); } bs.set(arg.vs); } else if (arg.type == CCVALTYPE.CODE_POINT) { addCodeRange(env, arg.vs, arg.vs); } break; case RANGE: if (arg.inType == arg.type) { if (arg.inType == CCVALTYPE.SB) { if (arg.vs > 0xff || arg.v > 0xff) { throw new ValueException(ErrorMessages.ERR_INVALID_CODE_POINT_VALUE); } if (arg.vs > arg.v) { if (env.syntax.allowEmptyRangeInCC()) { // goto ccs_range_end arg.state = CCSTATE.COMPLETE; break; } throw new ValueException(ErrorMessages.ERR_EMPTY_RANGE_IN_CHAR_CLASS); } bs.setRange(arg.vs, arg.v); } else { addCodeRange(env, arg.vs, arg.v); } } else { if (arg.vs > arg.v) { if (env.syntax.allowEmptyRangeInCC()) { // goto ccs_range_end arg.state = CCSTATE.COMPLETE; break; } throw new ValueException(ErrorMessages.ERR_EMPTY_RANGE_IN_CHAR_CLASS); } bs.setRange(arg.vs, arg.v < 0xff ? arg.v : 0xff); addCodeRange(env, arg.vs, arg.v); } // ccs_range_end: arg.state = CCSTATE.COMPLETE; break; case COMPLETE: case START: arg.state = CCSTATE.VALUE; break; default: break; } // switch arg.vsIsRaw = arg.vIsRaw; arg.vs = arg.v; arg.type = arg.inType; }
@SuppressWarnings("fallthrough") public int setQuantifier(final Node tgt, final boolean group, final ScanEnvironment env, final char[] chars, final int p, final int end) { if (lower == 1 && upper == 1) { return 1; } switch(tgt.getType()) { case STR: if (!group) { final StringNode sn = (StringNode)tgt; if (sn.canBeSplit()) { final StringNode n = sn.splitLastChar(); if (n != null) { setTarget(n); return 2; } } } break; case QTFR: /* check redundant double repeat. */ /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */ final QuantifierNode qnt = (QuantifierNode)tgt; final int nestQNum = popularNum(); final int targetQNum = qnt.popularNum(); if (Config.USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR) { if (!isByNumber() && !qnt.isByNumber() && env.syntax.warnReduntantNestedRepeat()) { switch(REDUCE_TABLE[targetQNum][nestQNum]) { case ASIS: break; case DEL: env.reg.getWarnings().warn(new String(chars, p, end) + " redundant nested repeat operator"); break; default: env.reg.getWarnings().warn(new String(chars, p, end) + " nested repeat operator " + PopularQStr[targetQNum] + " and " + PopularQStr[nestQNum] + " was replaced with '" + ReduceQStr[REDUCE_TABLE[targetQNum][nestQNum].ordinal()] + "'"); } } } // USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR if (targetQNum >= 0) { if (nestQNum >= 0) { reduceNestedQuantifier(qnt); return 0; } else if (targetQNum == 1 || targetQNum == 2) { /* * or + */ /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */ if (!isRepeatInfinite(upper) && upper > 1 && greedy) { upper = lower == 0 ? 1 : lower; } } } default: break; } setTarget(tgt); return 0; }
@SuppressWarnings("fallthrough") public int setQuantifier(Node tgt, boolean group, ScanEnvironment env, char[] chars, int p, int end) { if (lower == 1 && upper == 1) return 1; switch(tgt.getType()) { case STR: if (!group) { StringNode sn = (StringNode)tgt; if (sn.canBeSplit()) { StringNode n = sn.splitLastChar(); if (n != null) { setTarget(n); return 2; } } } break; case QTFR: /* check redundant double repeat. */ /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */ QuantifierNode qnt = (QuantifierNode)tgt; int nestQNum = popularNum(); int targetQNum = qnt.popularNum(); if (Config.USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR) { if (!isByNumber() && !qnt.isByNumber() && env.syntax.warnReduntantNestedRepeat()) { switch(REDUCE_TABLE[targetQNum][nestQNum]) { case ASIS: break; case DEL: env.reg.getWarnings().warn(new String(chars, p, end) + " redundant nested repeat operator"); break; default: env.reg.getWarnings().warn(new String(chars, p, end) + " nested repeat operator " + PopularQStr[targetQNum] + " and " + PopularQStr[nestQNum] + " was replaced with '" + ReduceQStr[REDUCE_TABLE[targetQNum][nestQNum].ordinal()] + "'"); } } } // USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR if (targetQNum >= 0) { if (nestQNum >= 0) { reduceNestedQuantifier(qnt); return 0; } else if (targetQNum == 1 || targetQNum == 2) { /* * or + */ /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */ if (!isRepeatInfinite(upper) && upper > 1 && greedy) { upper = lower == 0 ? 1 : lower; } } } default: break; } setTarget(tgt); return 0; }