Lines Matching refs:ANYOF

1220      * ANYOF node, with the first NUM_ANYOF_CODE_POINTS code points in a bit
5059   * code point, as this can be called as part of an ANYOF node, and they can
7545     /* Uses the inversion list '*invlist_ptr' to populate the ANYOF 'node'.  It
7553     if (REGNODE_TYPE(OP(node))  != ANYOF) {
8688                               FALSE, /* Require return to be an ANYOF */
8727                                 FALSE, /* Require return to be an ANYOF */
9060         /* About to generate an ANYOF (or similar) node from the inversion list
9082                         /* We can optimize into something besides an ANYOF,
9083                          * except under /l, which needs to be ANYOF because of
9110          * something other than an ANYOF node is simply to minimize the number
9115          * (One might think we could look at the resulting ANYOF node and
9123             assert(OP(REGNODE_p(node)) == ANYOF);
9409                  bool optimizable,                  /* ? Allow a non-ANYOF return
9415      * ANYOF node; but something like [a] will produce an EXACT node; [aA], an
9429      * ANYOF nodes contain a bit map for the first NUM_ANYOF_CODE_POINTS
9523     U8 op = ANYOF;    /* The returned node-type, initialized to the expected
9525     U8 anyof_flags = 0;   /* flag bits if the node is an ANYOF-type */
11083             /* Because an ANYOF node is the only one that warns, this node
11181          * execute, than ANYOF nodes.  EXACTish nodes may be joinable with
11200          * emit an ANYOF */
11202             op = ANYOF;
11206     /* Here are going to emit an ANYOF; set the particular type */
11207     if (op == ANYOF) {
11284      * ANYOF node.  The parameter names are the same as the corresponding
11289      * like plain ANYOF, it leaves *ret unchanged for allocation in S_regclass.
11445      * join this node with adjacent EXACTish ones, and ANYOF nodes require
11653                 /* If the fold list is identical to what's in this ANYOF node,
11898          * ones are about the same speed as ANYOF ops, but take less room; the
11900          * than ANYOF. */
11989                         /* Here, they precisely match.  Optimize this ANYOF
12216     /* Sets the arg field of an ANYOF-type node 'node', using information about
12240         /* On plain ANYOF nodes without the possibility of a runtime locale
12243         if (REGNODE_TYPE(OP(node)) == ANYOF && ! only_utf8_locale_list) {
12483     /* If requested, return a printable version of what this ANYOF node matches
12786     assert(extra_size >= REGNODE_ARG_LEN(op) || REGNODE_TYPE(op) == ANYOF);
12823     /* ANYOF are special cased to allow non-length 1 args */
13711             case 's': /* an RV (currently only used for an RV to an AV by the ANYOF code)