Lines Matching refs:node
956 * node.
967 * node.
1005 * If the Start node might possibly match supplementary characters.
1008 * (2) There is complement node of Category or Block
1322 * only a Start node and a LastNode node.
1705 private static void printObjectTree(Node node) {
1706 while(node != null) {
1707 if (node instanceof Prolog) {
1708 System.out.println(node);
1709 printObjectTree(((Prolog)node).loop);
1711 } else if (node instanceof Loop) {
1712 System.out.println(node);
1713 printObjectTree(((Loop)node).body);
1715 } else if (node instanceof Curly) {
1716 System.out.println(node);
1717 printObjectTree(((Curly)node).atom);
1719 } else if (node instanceof GroupCurly) {
1720 System.out.println(node);
1721 printObjectTree(((GroupCurly)node).atom);
1723 } else if (node instanceof GroupTail) {
1724 System.out.println(node);
1725 System.out.println("Tail next is "+node.next);
1728 System.out.println(node);
1730 node = node.next;
1731 if (node != null)
1733 if (node == Pattern.accept) {
1735 node = null;
1964 Node node = sequence(end);
1967 prev = node;
1975 if (node == end) {
1976 // if the node returned from sequence() is "end"
1979 node = null;
1985 ((Branch)prev).add(node);
1994 prev = new Branch(prev, node, branchConn);
2010 Node node = null;
2018 node = group0();
2020 if (node == null)
2023 head = node;
2025 tail.next = node;
2030 node = clazz(true);
2043 node = family(oneLetter, comp);
2046 node = atom();
2053 node = new UnixCaret();
2055 node = new Caret();
2057 node = new Begin();
2063 node = new UnixDollar(has(MULTILINE));
2065 node = new Dollar(has(MULTILINE));
2070 node = new All();
2073 node = new UnixDot();
2075 node = new Dot();
2084 node = atom();
2097 node = atom();
2101 node = closure(node);
2104 head = tail = node;
2106 tail.next = node;
2107 tail = node;
2151 } else { // No slice; just return the family node
2420 * Parse a character class, and return the node that matches it.
2424 * right hand node with "understood" brackets.
2428 CharProperty node = null;
2449 node = clazz(true);
2451 prev = node;
2453 prev = union(prev, node);
2475 node = rightNode;
2482 prev = intersection(prev, node);
2507 node = range(bits);
2510 prev = node;
2512 if (prev != node)
2513 prev = union(prev, node);
2517 prev = node.complement();
2519 if (prev != node)
2520 prev = setDifference(prev, node);
2529 Use "single" node instead of bits when dealing with unicode
2559 * and return its representative node.
2618 * Parses a Unicode character family and returns its representative node.
2625 CharProperty node = null;
2655 node = unicodeScriptPropertyFor(value);
2657 node = unicodeBlockPropertyFor(value);
2659 node = charPropertyNodeFor(value);
2667 node = unicodeBlockPropertyFor(name.substring(2));
2673 node = new Utype(uprop);
2674 if (node == null)
2675 node = CharPropertyNames.charPropertyFor(name);
2676 if (node == null)
2677 node = unicodeScriptPropertyFor(name);
2682 node = new Utype(uprop);
2684 if (node == null)
2685 node = charPropertyNodeFor(name);
2689 if (node instanceof Category || node instanceof Block)
2691 node = node.complement();
2693 return node;
2753 * Parses a group and returns the head node of a set of nodes that process
2861 Node node = closure(head);
2862 if (node == head) { // No closure
2864 return node; // Dual return
2867 root = node;
2868 return node; // Dual return
2871 if (node instanceof Ques) {
2872 Ques ques = (Ques) node;
2874 root = node;
2875 return node;
2886 } else if (node instanceof Curly) {
2887 Curly curly = (Curly) node;
2889 root = node;
2890 return node;
3341 * Base class for all node classes. Subclasses should override the match()
3342 * method as appropriate. This class is an accepting node, so its match()
3351 * This method implements the classic accept node.
3373 * This method implements the classic accept node with
3391 * or a BnM will bypass this node completely.
3395 Start(Node node) {
3396 this.next = node;
3430 StartS(Node node) {
3431 super(node);
3681 * Abstract node class to match one character satisfying some
4003 * Returns node for matching characters within an explicit value range.
4013 * Returns node for matching characters within an explicit value
4072 Ques(Node node, int type) {
4073 this.atom = node;
4116 Curly(Node node, int cmin, int cmax, int type) {
4117 this.atom = node;
4263 GroupCurly(Node node, int cmin, int cmax, int type, int local,
4265 this.atom = node;
4457 * A Guard node at the end of each atom node in a Branch. It
4460 * of each atom node without including the TreeInfo of the
4488 void add(Node node) {
4494 atoms[size++] = node;
4595 * The GroupTail node is also used when a previous group is referenced,
4881 First(Node node) {
4882 this.atom = BnM.optimize(node);
5293 static Node optimize(Node node) {
5294 if (!(node instanceof Slice)) {
5295 return node;
5298 int[] src = ((Slice) node).buffer;
5305 return node;
5340 if (node instanceof SliceS)
5341 return new BnMS(src, lastOcc, optoSft, node.next);
5342 return new BnM(src, lastOcc, optoSft, node.next);
5378 // BnM is only used as the leading node in the unanchored case,