binutils/libiberty/regex.c

316    not functions -- `alloca'-allocated space disappears at the end of the
386    `string1' or just past its end.  This works if PTR is NULL, which is
519         /* Fail unless at end of line.  */
526         /* Analogously, for end of buffer/string.  */
532 	/* Same as jump, but marks the end of an alternative.  */
567 	/* Push a dummy failure point and continue.  Used at the end of
591   wordend,	/* Succeeds if at word end.  */
813 PREFIX(print_partial_compiled_pattern) (UCHAR_T *start, UCHAR_T *end)
818   UCHAR_T *pend = end;
1367     gettext_noop ("Invalid range end"),	/* REG_ERANGE */
1370     gettext_noop ("Premature end of regular expression"), /* REG_EEND */
1643 	  DEBUG_PRINT2 ("    end: %p\n", regend[this_reg]);		\
1770 	DEBUG_PRINT2 ("      end: %p\n", regend[this_reg]);		\
1858                                 int arg, UCHAR_T *end);
1860                                 int arg1, int arg2, UCHAR_T *end);
1875 static void insert_space (int num, CHAR_T *loc, CHAR_T *end);
1991 /* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */
1995 /* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */
2005    MSC and drop MAX_BUF_SIZE a bit.  Otherwise you may end up
2319   /* Points to the end of the buffer, where we should append.  */
2351   /* Address of the place where a forward jump should go to the end of
2419      at the end.  */
2465   /* Loop through the uncompiled pattern until we're at the end.  */
2489             if (   /* If at end of pattern, it's an operator.  */
2576                    end a backward relative jump from `b' to before the next
2613                end of the buffer after this jump is inserted.  */
2751                 /* Could be the end of the bracket expression.  If it's
2764                    beginning or the end of a list, then it's the range
2774 		    /* Update the pointer to indicate end of buffer.  */
2789 		    /* Update the pointer to indicate end of buffer.  */
2835                         /* Throw away the ] at the end of the character
2843 			/* Update the pointer to indicate end of buffer.  */
3034 				    /* Throw away the ] at the end of the
3046                         /* Throw away the ] at the end of the equivalence
3053 			/* Update the pointer to indicate end of buffer.  */
3162                 /* Could be the end of the bracket expression.  If it's
3175                    beginning or the end of a list, then it's the range
3242                         /* Throw away the ] at the end of the character
3282                         /* Throw away the ] at the end of the character
3367 			    /* Throw away the ] at the end of the equivalence
3406 			    /* Throw away the ] at the end of the equivalence
3502 			    /* Throw away the ] at the end of the equivalence
3565 			    /* Throw away the ] at the end of the equivalence
3611                end of the map.  Decrease the map-length byte too.  */
3682               /* These are the values to restore when we hit end of this
3728                 { /* Push a dummy failure point at the end of the
3770                 /* We're at the end of the group, so now we know how many
3821                  when know we're at the end of a series of alternatives.  */
3897 		   the end of the buffer after we insert the jump.  */
3919                         more at the end of the loop.  */
4166      the first time we reach the end of the compiled pattern.  */
4266 PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc, int arg, UCHAR_T *end)
4268   register UCHAR_T *pfrom = end;
4269   register UCHAR_T *pto = end + 1 + OFFSET_ADDRESS_SIZE;
4283                     int arg2, UCHAR_T *end)
4285   register UCHAR_T *pfrom = end;
4286   register UCHAR_T *pto = end + 1 + 2 * OFFSET_ADDRESS_SIZE;
4358    "end" must point the end of the allocated buffer.  */
4360 insert_space (int num, CHAR_T *loc, CHAR_T *end)
4362   register CHAR_T *pto = end;
4363   register CHAR_T *pfrom = end - num;
4413       /* Insert space to the end of the char_ranges.  */
4430       /* Insert space to the end of the char_ranges.  */
4604 	  /* We have reached the (effective) end of pattern.  */
4620       /* We should never be about to go beyond the end of the pattern.  */
4636       /* Following are the cases which match a character.  These end
4672 	  /* Chars beyond end of map must be allowed.  */
4734       /* All cases after this match the empty string.  These end with
4796              end of the pattern.  We don't want to push such a point,
4798              increment `p' past the end of the pattern.  We don't need
4912       regs->end = ends;
4918       regs->start = regs->end = (regoff_t *) 0;
5304 /* Test if at very beginning or at very end of the virtual concatenation
5311    two special cases to check for: if past the end of string1, look at
5439                                                   UCHAR_T *end,
5442                                                 UCHAR_T *end,
5445                                                       UCHAR_T *end,
5577   /* Just past the end of the corresponding string.  */
5584   /* Where we are in the data, and the end of the current string.  */
5587   /* Where we are in the pattern, and the end of the pattern.  */
5650      register's end.  */
5679      the end of the best match so far in a separate variable.  We
5866      `dend' is the end of the input string that `d' points within.  `d'
5869      loop, `d' can be pointing at the end of a string, but it cannot
5922           DEBUG_PRINT1 ("end of pattern ... ");
6001                   regs->end = TALLOC (regs->num_regs, regoff_t);
6002                   if (regs->start == NULL || regs->end == NULL)
6017                       RETALLOC (regs->end, regs->num_regs, regoff_t);
6018                       if (regs->start == NULL || regs->end == NULL)
6040 		    regs->end[0] = mbs_offset1 != NULL ?
6043 		    regs->end[0] = csize1 + (mbs_offset2 != NULL ?
6046                   regs->end[0] = (MATCHING_IN_FIRST_STRING
6058                     regs->start[mcnt] = regs->end[mcnt] = -1;
6063                       regs->end[mcnt]
6072                  -1 at the end.  */
6074                 regs->start[mcnt] = regs->end[mcnt] = -1;
6525 		    /* If range_start(or end) < 0, we assume -range_start(end)
6527 		       as the character of the range start(end).  */
6636         /* The stop_memory opcode represents the end of a group.  Its
6679               /* If we end up at register zero, that means that we saved
6793                the end of the first string.  */
6811 		/* At end of register contents => success */
6884 	/* Match at the very end of the data.  */
6988                pattern follows its end. If we can establish that there
6998                failure point which is what we will end up popping.  */
7022             /* If we're at the end of the pattern, we can change.  */
7143 	/* The end of a simple repeat has a pop_failure_jump back to
7188         /* We need this opcode so we can detect where alternatives end
7196            then gets popped at pop_failure_jump.  We will end up at
7208         /* At the end of an alternative, we need to push a dummy failure
7456           /* If we failed to the end of the pattern, don't examine *p.  */
7515 PREFIX(group_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
7522   while (p1 < end)
7543                  whereas the rest start with on_failure_jump and end
7612           if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
7615     } /* while p1 < end */
7626 PREFIX(alt_match_null_string_p) (UCHAR_T *p, UCHAR_T *end,
7632   while (p1 < end)
7647           if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
7650     }  /* while p1 < end */
7662 PREFIX(common_op_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
7691       ret = PREFIX(group_match_null_string_p) (&p1, end, reg_info);
8018    string; if REG_NOTEOL is set, then $ does not match at the end.
8048       regs.end = regs.start + nmatch;
8066               pmatch[r].rm_eo = regs.end[r];