gcc/fixinc/gnu-regex.c

21    along with this program; if not, write to the Free Software Foundation,
81 #else  /* not emacs */
93 /* If we are not linking with Emacs proper,
165 # else /* not SYNTAX_TABLE */
194 # endif /* not SYNTAX_TABLE */
198 #endif /* not emacs */
202 /* CYGNUS LOCAL: call it gnu-regex.h, not regex.h, to avoid name conflicts */
261 #else  /* not __STDC__ */
267 /* Should we use malloc or alloca?  If REGEX_MALLOC is not defined, we
274    not functions -- `alloca'-allocated space disappears at the end of the
283 #else /* not REGEX_MALLOC  */
291 #  else /* not __GNUC__ */
295 #  endif /* not __GNUC__ */
297 # endif /* not alloca */
309 #endif /* not REGEX_MALLOC */
322 #else /* not using relocating allocator */
330 # else /* not REGEX_MALLOC */
339 # endif /* not REGEX_MALLOC */
340 #endif /* not using relocating allocator */
400            automatically not in the set.  */
404            not one of those specified.  */
436            of string to be matched (if not).  */
494   notwordchar,	/* Matches any char that is not a word-constituent.  */
500   notwordbound	/* Succeeds if not at a word boundary.  */
511 	/* Matches any character whose syntax is not that specified.  */
561 # endif /* not EXTRACT_MACROS */
590 # endif /* not EXTRACT_MACROS */
953 #else /* not DEBUG */
966 #endif /* not DEBUG */
994   else if (debug) /* was on but now is not */
1007    but why not be nice?  */
1034    searching and matching functions should not call alloca.  On some
1048    faith that they will not malloc.  */
1053 /* When using GNU C, we are not REALLY using the C alloca, no matter
1059 /* The match routines may not allocate if (1) they would do it with malloc
1060    and (2) it's not safe for them to use malloc.
1061    Note that if REL_ALLOC is defined, matching would not use malloc for the
1063    so REL_ALLOC should not affect this.  */
1077    space, so it is not a hard limit.  */
1112 #else /* not INT_IS_16BIT */
1226 /* Used to omit pushing failure point id's when we're not debugging.  */
1250     /* Can't be int, since there is not a shred of a guarantee that int	\
1457          zero if not.  If not yet determined,  `MATCH_NULL_UNSET_VALUE'.  */
1608 /* This is not an arbitrary limit: the arguments which represent offsets
1614    reallocating to 0 bytes.  Such thing is not going to work too well.
1619    but is not required. */
1671 /* int may be not enough when sizeof(int) == 2.  */
1799 #endif /* not MATCH_MAY_ALLOCATE */
1914   /* Always count groups, whether or not bufp->no_sub is set.  */
1931         { /* Caller did not allocate a buffer.  Do it for them.  */
2048             /* Now we know whether or not zero matches is allowed
2049                and also whether or not two or more matches is allowed.  */
2066                 /* We know we are not at the first character of the pattern,
2167                    not (i.e., when the bracket expression is `[]' so
2178                    was a character: if this is a hyphen not at the
2231 /* defined in the 1994 Amendment 1 to ISO C and may not be present on */
2379           /* Do not translate the character after the \, so that we can
2414                  groups inner to this one.  But do not push a
2553                      /* If we're at `\{' and it's not the open-interval
2821                  not to translate; but if we don't translate it
2835               /* If last exactn not at current position.  */
2916 # else /* not emacs */
2926 # endif /* not emacs */
2931 #endif /* not MATCH_MAY_ALLOCATE */
3048    false if it's not.  */
3203         /* I guess the idea here is to simply not bother with a fastmap
3411          string does not match.  We need not follow this path further.
3505    Do not consider matching one past the index STOP in the virtual
3561   /* Update the fastmap now if not correct already.  */
3717 #endif /* not MATCH_MAY_ALLOCATE */
3719 /* These values must meet several constraints.  They must not be valid
3724    be larger than the value for the highest register, so we do not try
3754 #endif /* not emacs */
3893      field of reg_info[reg_num] helps us tell whether or not we have
3904      turn happens only if we have not yet matched the entire string. */
3911      allocate space for that if we're not allocating space for anything
3917      and need to test it, it's not garbage.  */
3939   /* Do not bother to initialize all the register variables if there are
3994   /* We move `string1' into `string2' if the latter's empty -- but not if
4106                      not consecutive in memory.  */
4282 	    boolean not = (re_opcode_t) *(p - 1) == charset_not;
4284             DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : "");
4293 	      not = !not;
4297 	    if (!not) goto fail;
4398                  the registers as the result of an `on_failure_jump', not
4711                This is not true in the case of alternatives: in
4766 		    int not = (re_opcode_t) p1[3] == charset_not;
4770 		      not = !not;
4772                     /* `not' is equal to 1 if c would match, which means
4774 		    if (!not)
5112 #else /* not emacs */
5130 #endif /* not emacs */
5231           /* If the next operation is not a jump backwards in the
5273 		  /* Still have to check that it's not an n-th
5483   /* And GNU code determines whether or not to get register information
5484      by passing null for the REGS argument to re_match, etc., not by
5578    PREG is a regex_t *.  We do not expect any fields to be initialized,
5686    REG_NOTBOL is set, then ^ does not match at the beginning of the
5687    string; if REG_NOTEOL is set, then $ does not match at the end.
5689    We return 0 if we find a match and REG_NOMATCH if not.  */
5830 #endif /* not emacs  */