Lines Matching refs:EXACT

1673          * EXACT node with one byte input, one byte output.  This is crude, and
1936          * NOTE that EXACT is NOT covered here, as it is normally
1975         /* Ignore EXACT as we deal with it later. */
1976         if (REGNODE_TYPE(OP(first)) == EXACT) {
2328          * the right type (not EXACT, for example).
2344                   && (REGNODE_TYPE(fop) == EXACT && ! isEXACTFish(fop))
5451                 : EXACT;
6203             /* We start out as an EXACT node, even if under /i, until we find a
6212             U8 node_type = EXACT;
6260             /* Allocate an EXACT node.  The node_type may change below to
6276             node_type = EXACT;
6701                     else if (node_type == EXACT) {
6739                     if (len && node_type != EXACT) {
6757                     else if (node_type == EXACT) {
6910             /* Here we have run out of room.  We can grow plain EXACT and
6914             if (! LOC && (node_type == EXACT || node_type == LEXACT)) {
6927                 /* If would have overflowed a regular EXACT node, switch
6929                  * the actual growing code is common to changing from an EXACT
6931                  * to save the string in the EXACT case before growing, and
6933                 if (node_type == EXACT) {
6934                     overhead_expansion = REGNODE_ARG_LEN(LEXACT) - REGNODE_ARG_LEN(EXACT);
6939                 /* Ready to grow.  If it was a plain EXACT, the string was
6964                  * EXACT node now converted to LEXACT, and the string has to be
7404              * old code handled this situation by creating a zero-length EXACT
7411                 /* If the node type is EXACT here, check to see if it
7413                 if (node_type == EXACT) {
9415      * ANYOF node; but something like [a] will produce an EXACT node; [aA], an
11460      * On the other hand qr/:/i should generate a plain EXACT node since the
11461      * colon participates in no fold whatsoever, and having it be EXACT tells
11491                 op = (lowest_cp < 256) ? EXACT : EXACT_REQ8;
11497                  * doesn't participate in a fold should be an EXACT node.  We
11501                  * create an EXACT node, as we would wrongly be telling the
11513                      : EXACT;
13008 - currently only looks for EXACT chains.
13045         if (REGNODE_TYPE(OP(REGNODE_p(scan))) == EXACT) {
13049                 return TRUE; /* Was return EXACT */
13053             if (REGNODE_TYPE(OP(REGNODE_p(scan))) == EXACT) {