private static int compileLengthCClassNode(final CClassNode cc) { if (cc.isShare()) { return OPSize.OPCODE + OPSize.POINTER; } int len; if (cc.mbuf == null) { len = OPSize.OPCODE + BitSet.BITSET_SIZE; } else { if (cc.bs.isEmpty()) { len = OPSize.OPCODE; } else { len = OPSize.OPCODE + BitSet.BITSET_SIZE; } len += OPSize.LENGTH + cc.mbuf.used; } return len; }
private int compileLengthCClassNode(CClassNode cc) { if (cc.isShare()) return OPSize.OPCODE + OPSize.POINTER; int len; if (cc.mbuf == null) { len = OPSize.OPCODE + BitSet.BITSET_SIZE; } else { if (cc.bs.isEmpty()) { len = OPSize.OPCODE; } else { len = OPSize.OPCODE + BitSet.BITSET_SIZE; } len += OPSize.LENGTH + cc.mbuf.used; } return len; }
@Override protected void compileCClassNode(final CClassNode cc) { if (cc.isShare()) { // shared char class addOpcode(OPCode.CCLASS_NODE); addPointer(cc); return; } if (cc.mbuf == null) { if (cc.isNot()) { addOpcode(OPCode.CCLASS_NOT); } else { addOpcode(OPCode.CCLASS); } addInts(cc.bs.bits, BitSet.BITSET_SIZE); // add_bitset } else { if (cc.bs.isEmpty()) { if (cc.isNot()) { addOpcode(OPCode.CCLASS_MB_NOT); } else { addOpcode(OPCode.CCLASS_MB); } addMultiByteCClass(cc.mbuf); } else { if (cc.isNot()) { addOpcode(OPCode.CCLASS_MIX_NOT); } else { addOpcode(OPCode.CCLASS_MIX); } // store the bit set and mbuf themself! addInts(cc.bs.bits, BitSet.BITSET_SIZE); // add_bitset addMultiByteCClass(cc.mbuf); } } }
public static void apply(final int from, final int to, final Object o) { final ApplyCaseFoldArg arg = (ApplyCaseFoldArg)o; final ScanEnvironment env = arg.env; final CClassNode cc = arg.cc; final BitSet bs = cc.bs; final boolean inCC = cc.isCodeInCC(from); if (Config.CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS) { if ((inCC && !cc.isNot()) || (!inCC && cc.isNot())) { if (to >= BitSet.SINGLE_BYTE_SIZE) { cc.addCodeRange(env, to, to); } else { /* /(?i:[^A-C])/.match("a") ==> fail. */ bs.set(to); } } } else { if (inCC) { if (to >= BitSet.SINGLE_BYTE_SIZE) { if (cc.isNot()) { cc.clearNotFlag(); } cc.addCodeRange(env, to, to); } else { if (cc.isNot()) { bs.clear(to); } else { bs.set(to); } } } } // CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS }
private void opCClassNode() { if (s >= range) {opFail(); return;} final CClassNode cc = (CClassNode)regex.operands[code[ip++]]; final int ss = s; s++; final int c = chars[ss]; if (!cc.isCodeInCCLength(c)) {opFail(); return;} sprev = sbegin; // break; }
@Override protected void compileCClassNode(CClassNode cc) { if (cc.isShare()) { // shared char class addOpcode(OPCode.CCLASS_NODE); addPointer(cc); return; } if (cc.mbuf == null) { if (cc.isNot()) { addOpcode(OPCode.CCLASS_NOT); } else { addOpcode(OPCode.CCLASS); } addInts(cc.bs.bits, BitSet.BITSET_SIZE); // add_bitset } else { if (cc.bs.isEmpty()) { if (cc.isNot()) { addOpcode(OPCode.CCLASS_MB_NOT); } else { addOpcode(OPCode.CCLASS_MB); } addMultiByteCClass(cc.mbuf); } else { if (cc.isNot()) { addOpcode(OPCode.CCLASS_MIX_NOT); } else { addOpcode(OPCode.CCLASS_MIX); } // store the bit set and mbuf themself! addInts(cc.bs.bits, BitSet.BITSET_SIZE); // add_bitset addMultiByteCClass(cc.mbuf); } } }
private void opCClassNode() { if (s >= range) {opFail(); return;} CClassNode cc = (CClassNode)regex.operands[code[ip++]]; int ss = s; s++; int c = chars[ss]; if (!cc.isCodeInCCLength(c)) {opFail(); return;} sprev = sbegin; // break; }
private int compileLengthTree(final Node node) { int len = 0; switch (node.getType()) { case NodeType.LIST: ConsAltNode lin = (ConsAltNode)node; do { len += compileLengthTree(lin.car); } while ((lin = lin.cdr) != null); break; case NodeType.ALT: ConsAltNode aln = (ConsAltNode)node; int n = 0; do { len += compileLengthTree(aln.car); n++; } while ((aln = aln.cdr) != null); len += (OPSize.PUSH + OPSize.JUMP) * (n - 1); break; case NodeType.STR: final StringNode sn = (StringNode)node; if (sn.isRaw()) { len = compileLengthStringRawNode(sn); } else { len = compileLengthStringNode(sn); } break; case NodeType.CCLASS: len = compileLengthCClassNode((CClassNode)node); break; case NodeType.CTYPE: case NodeType.CANY: len = OPSize.OPCODE; break; case NodeType.BREF: final BackRefNode br = (BackRefNode)node; len = ((!isIgnoreCase(regex.options) && br.backRef <= 2) ? OPSize.OPCODE : (OPSize.OPCODE + OPSize.MEMNUM)); break; case NodeType.QTFR: len = compileNonCECLengthQuantifierNode((QuantifierNode)node); break; case NodeType.ENCLOSE: len = compileLengthEncloseNode((EncloseNode)node); break; case NodeType.ANCHOR: len = compileLengthAnchorNode((AnchorNode)node); break; default: newInternalException(ERR_PARSER_BUG); } //switch return len; }
public ApplyCaseFoldArg(final ScanEnvironment env, final CClassNode cc) { this.env = env; this.cc = cc; }
protected final void compileTree(final Node node) { switch (node.getType()) { case NodeType.LIST: ConsAltNode lin = (ConsAltNode)node; do { compileTree(lin.car); } while ((lin = lin.cdr) != null); break; case NodeType.ALT: compileAltNode((ConsAltNode)node); break; case NodeType.STR: final StringNode sn = (StringNode)node; if (sn.isRaw()) { compileStringRawNode(sn); } else { compileStringNode(sn); } break; case NodeType.CCLASS: compileCClassNode((CClassNode)node); break; case NodeType.CANY: compileAnyCharNode(); break; case NodeType.BREF: compileBackrefNode((BackRefNode)node); break; case NodeType.QTFR: compileNonCECQuantifierNode((QuantifierNode)node); break; case NodeType.ENCLOSE: final EncloseNode enode = (EncloseNode)node; if (enode.isOption()) { compileOptionNode(enode); } else { compileEncloseNode(enode); } break; case NodeType.ANCHOR: compileAnchorNode((AnchorNode)node); break; default: // undefined node type newInternalException(ERR_PARSER_BUG); } // switch }
