Lines Matching defs:literal

714             /* overloading involved: all bets are off over literal
855  * or indirect literal code blocks. Now, take the pattern 'pat' and make a
856  * copy of it, but with any literal code blocks blanked out and
863  *       a\bc(?{"this was literal"})def'ghi\\jkl(?{"this is runtime"})mno
918                 /* blank out literal code block so that they aren't
1559                 /* this second condition covers the non-regex literal case,
2049         * longest literal string that must appear and make it the
5486    as much literal text as we can.  If we encounter a quantifier, we have to
5487    back off the final literal character, as that quantifier applies to just it
5499    Note: we have to be careful with escapes, as they can be both literal
5513                 cases for each ambiguous special/literal:
5517                 default: // unambiguously literal:
5520         default:  // is a literal char
5523             create EXACTish node for literal;
5540    escape sequences, with the one for handling literal escapes requiring
5652            of special regop and not to literal text. Escape sequences that
5653            resolve to literal text are handled below in the switch marked
5657            in the literal escape switch. However, the opposite is not
5659            literal text handling code.
5910              * single code point; we handle those like any other literal.  The
6186              * literal character.  RExC_parse points to the first byte of its
6302             /* Here, we have a literal character.  Find the maximal string of
6304              * We quit at the first non-literal or when the node gets full, or
6338                        resolve to a literal character.
6345                        an unescaped equivalent literal.
6370                        literal. (Except digits, which may or may not)
6582                      *  2)  If the literal '{' conflicts with our desired use
6589                      *      the quantifier would silently be taken as a literal
6608                         ckWARN2reg(p + 1, "Unescaped literal '%c'", *p);
6611                 default:    /* A literal character */
6622                 } /* End of switch on the literal */
6624                 /* Here, have looked at the literal character, and <ender>
6665                 if (! FOLD) {  /* The simple case, just append the literal */
6899             } /* End of loop through literal characters */
7463                          * literal string capacity */
7830          * classes.  For example [.].] means a literal right bracket instead of
9499      * character in ASCII vs. EBCDIC, as opposed to, say, a literal 'A' or a
10165              * literal, as is the character that began the false range, i.e.
10362                  * it is a literal minus; otherwise it is a range */
10586                     char literal[3];
10589                         literal[d++] = '\\';
10591                     literal[d++] = (char) value;
10592                     literal[d++] = '\0';
10598                            literal