Attachment #873140 for bug #915999

View | Details | Raw Unified | Return to bug 915999
Collapse All | Expand All




int
glob_pattern_p (const char *pattern)
{
  const char *p = pattern;
  char c;
  int	open = 0;

  while ((c = *p++) != '\0')

int
glob_match (const char *pattern, const char *text, int dot_special)
{
  char const *p = pattern, *t = text;
  char c;

  while ((c = *p++) != '\0')
    switch (c)


      case '[':
	{
	  char c1 = *t++;
	  int invert;

	  if (!c1)

	  c = *p++;
	  while (1)
	    {
	      char cstart = c, cend = c;

	      if (c == '\\')
		{

static int
glob_match_after_star (const char *pattern, const char *text)
{
  const char *p = pattern, *t = text;
  char c, c1;

  while ((c = *p++) == '?' || c == '*')
    if (c == '?' && *t++ == '\0')

    };

  DIR *d;
  struct dirent *dp;
  struct globval *lastlink;
  struct globval *nextlink;
  char *nextname;
  unsigned int count;
  int lose;
  char **name_vector = 0;
  unsigned int i;
#if defined (OPENDIR_NOT_ROBUST)
  struct stat finfo;


static char **
glob_dir_to_array (char *dir, char **array)
{
  unsigned int i, l;
  int add_slash;
  char **result;


  if (glob_pattern_p (directory_name))
    {
      char **directories;
      unsigned int i;

      if (directory_name[directory_len - 1] == '/')
	directory_name[directory_len - 1] = '\0';

	  else
	    {
	      char **array = glob_dir_to_array (directories[i], temp_results);
	      unsigned int l;

	      l = 0;
	      while (array[l] != 0)

 memory_error:
  if (result != 0)
    {
      unsigned int i;
      for (i = 0; result[i] != 0; ++i)
	free (result[i]);
      free ((char *) result);

Lines 26-32 Link Here

(-)a/ddd/my-dirent.h (-1 / +1 lines)
26	// or send a mail to the DDD developers <ddd@gnu.org>.	26	// or send a mail to the DDD developers <ddd@gnu.org>.
27		27
28	#ifndef _DDD_my_dirent_h	28	#ifndef _DDD_my_dirent_h
29	#define _DDD_my_Dirent_h	29	#define _DDD_my_dirent_h
30		30
31	#include "config.h"	31	#include "config.h"
32	#include <sys/types.h>	32	#include <sys/types.h>




 */
YY_DECL
{
	ddd_state_type ddd_current_state;
	char *ddd_cp, *ddd_bp;
	int ddd_act;
    
#line 233 "./rxscan.L"


ddd_match:
		do
			{
			YY_CHAR ddd_c = ddd_ec[YY_SC_TO_UI(*ddd_cp)];
			if ( ddd_accept[ddd_current_state] )
				{
				(ddd_last_accepting_state) = ddd_current_state;

 */
static int ddd_get_next_buffer (void)
{
   char *dest = YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf;
	char *source = (dddtext_ptr);
	int number_to_move, i;
	int ret_val;

	if ( (ddd_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[(ddd_n_chars) + 1] )


    static ddd_state_type ddd_get_previous_state (void)
{
	ddd_state_type ddd_current_state;
	char *ddd_cp;
    
	ddd_current_state = (ddd_start);

	for ( ddd_cp = (dddtext_ptr) + YY_MORE_ADJ; ddd_cp < (ddd_c_buf_p); ++ddd_cp )
		{
		YY_CHAR ddd_c = (*ddd_cp ? ddd_ec[YY_SC_TO_UI(*ddd_cp)] : 3);
		if ( ddd_accept[ddd_current_state] )
			{
			(ddd_last_accepting_state) = ddd_current_state;

 */
    static ddd_state_type ddd_try_NUL_trans  (ddd_state_type ddd_current_state )
{
	int ddd_is_jam;
   char *ddd_cp = (ddd_c_buf_p);

	YY_CHAR ddd_c = 3;
	if ( ddd_accept[ddd_current_state] )
		{
		(ddd_last_accepting_state) = ddd_current_state;

	return ddd_is_jam ? 0 : ddd_current_state;
}

    static void dddunput (int c, char * ddd_bp )
{
	char *ddd_cp;
    
    ddd_cp = (ddd_c_buf_p);


	if ( ddd_cp < YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		int number_to_move = (ddd_n_chars) + 2;
		char *dest = &YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[
				YY_CURRENT_BUFFER_LVALUE->ddd_buf_size + 2];
		char *source =
				&YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[number_to_move];

		while ( source > YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf )

#ifndef dddtext_ptr
static void ddd_flex_strncpy (char* s1, dddconst char * s2, int n )
{
	int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
}

#ifdef YY_NEED_STRLEN
static int ddd_flex_strlen (dddconst char * s )
{
	int n;
	for ( n = 0; s[n]; ++n )
		;


Lines 1543-1549 std::istream& operator>>(std::istream& s, string& x) Link Here

(-)a/ddd/strclass.C (-2 / +2 lines)
1543	int ch;	1543	int ch;
1544	unsigned i = 0;	1544	unsigned i = 0;
1545	x.rep = string_Sresize(x.rep, 20);	1545	x.rep = string_Sresize(x.rep, 20);
1546	register std::streambuf *sb = s.rdbuf();	1546	std::streambuf *sb = s.rdbuf();
1547	while ((ch = sb->sbumpc()) != EOF)	1547	while ((ch = sb->sbumpc()) != EOF)
1548	{	1548	{
1549	if (isspace(ch))	1549	if (isspace(ch))
Lines 1586-1592 int readline(std::istream& s, string& x, char terminator, int discard) Link Here
1586	int ch;	1586	int ch;
1587	unsigned i = 0;	1587	unsigned i = 0;
1588	x.rep = string_Sresize(x.rep, 80);	1588	x.rep = string_Sresize(x.rep, 80);
1589	register std::streambuf *sb = s.rdbuf();	1589	std::streambuf *sb = s.rdbuf();
1590	while ((ch = sb->sbumpc()) != EOF)	1590	while ((ch = sb->sbumpc()) != EOF)
1591	{	1591	{
1592	if (ch != terminator \|\| !discard)	1592	if (ch != terminator \|\| !discard)




 */
YY_DECL
{
	vsl_state_type vsl_current_state;
	char *vsl_cp, *vsl_bp;
	int vsl_act;
    
#line 246 "./vsl-lex.L"


vsl_match:
		do
			{
			YY_CHAR vsl_c = vsl_ec[YY_SC_TO_UI(*vsl_cp)];
			if ( vsl_accept[vsl_current_state] )
				{
				(vsl_last_accepting_state) = vsl_current_state;

 */
static int vsl_get_next_buffer (void)
{
    char *dest = YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf;
	char *source = (vsltext_ptr);
	int number_to_move, i;
	int ret_val;

	if ( (vsl_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[(vsl_n_chars) + 1] )


    static vsl_state_type vsl_get_previous_state (void)
{
	vsl_state_type vsl_current_state;
	char *vsl_cp;
    
	vsl_current_state = (vsl_start);
	vsl_current_state += YY_AT_BOL();

	for ( vsl_cp = (vsltext_ptr) + YY_MORE_ADJ; vsl_cp < (vsl_c_buf_p); ++vsl_cp )
		{
		YY_CHAR vsl_c = (*vsl_cp ? vsl_ec[YY_SC_TO_UI(*vsl_cp)] : 1);
		if ( vsl_accept[vsl_current_state] )
			{
			(vsl_last_accepting_state) = vsl_current_state;

 */
    static vsl_state_type vsl_try_NUL_trans  (vsl_state_type vsl_current_state )
{
	int vsl_is_jam;
    char *vsl_cp = (vsl_c_buf_p);

	YY_CHAR vsl_c = 1;
	if ( vsl_accept[vsl_current_state] )
		{
		(vsl_last_accepting_state) = vsl_current_state;

	return vsl_is_jam ? 0 : vsl_current_state;
}

    static void vslunput (int c, char * vsl_bp )
{
	char *vsl_cp;
    
    vsl_cp = (vsl_c_buf_p);


	if ( vsl_cp < YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		int number_to_move = (vsl_n_chars) + 2;
		char *dest = &YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[
				YY_CURRENT_BUFFER_LVALUE->vsl_buf_size + 2];
		char *source =
				&YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[number_to_move];

		while ( source > YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf )

#ifndef vsltext_ptr
static void vsl_flex_strncpy (char* s1, vslconst char * s2, int n )
{
	int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
}

#ifdef YY_NEED_STRLEN
static int vsl_flex_strlen (vslconst char * s )
{
	int n;
	for ( n = 0; s[n]; ++n )
		;

- 

Return to bug 915999

Lines 78-85 static int glob_match_after_star (const char pattern, const char text); Link Here

(-)a/ddd/glob.C (-17 / +17 lines)
78	int	78	int
79	glob_pattern_p (const char *pattern)	79	glob_pattern_p (const char *pattern)
80	{	80	{
81	register const char *p = pattern;	81	const char *p = pattern;
82	register char c;	82	char c;
83	int open = 0;	83	int open = 0;
84		84
85	while ((c = *p++) != '\0')	85	while ((c = *p++) != '\0')
Lines 127-134 glob_pattern_p (const char *pattern) Link Here
127	int	127	int
128	glob_match (const char pattern, const char text, int dot_special)	128	glob_match (const char pattern, const char text, int dot_special)
129	{	129	{
130	register char const p = pattern, t = text;	130	char const p = pattern, t = text;
131	register char c;	131	char c;
132		132
133	while ((c = *p++) != '\0')	133	while ((c = *p++) != '\0')
134	switch (c)	134	switch (c)
Lines 152-158 glob_match (const char pattern, const char text, int dot_special) Link Here
152		152
153	case '[':	153	case '[':
154	{	154	{
155	register char c1 = *t++;	155	char c1 = *t++;
156	int invert;	156	int invert;
157		157
158	if (!c1)	158	if (!c1)
Lines 165-171 glob_match (const char pattern, const char text, int dot_special) Link Here
165	c = *p++;	165	c = *p++;
166	while (1)	166	while (1)
167	{	167	{
168	register char cstart = c, cend = c;	168	char cstart = c, cend = c;
169		169
170	if (c == '\\')	170	if (c == '\\')
171	{	171	{
Lines 225-232 glob_match (const char pattern, const char text, int dot_special) Link Here
225	static int	225	static int
226	glob_match_after_star (const char pattern, const char text)	226	glob_match_after_star (const char pattern, const char text)
227	{	227	{
228	register const char p = pattern, t = text;	228	const char p = pattern, t = text;
229	register char c, c1;	229	char c, c1;
230		230
231	while ((c = p++) == '?' \|\| c == '')	231	while ((c = p++) == '?' \|\| c == '')
232	if (c == '?' && *t++ == '\0')	232	if (c == '?' && *t++ == '\0')
Lines 275-288 glob_vector (const char pat, const char dir) Link Here
275	};	275	};
276		276
277	DIR *d;	277	DIR *d;
278	register struct dirent *dp;	278	struct dirent *dp;
279	struct globval *lastlink;	279	struct globval *lastlink;
280	register struct globval *nextlink;	280	struct globval *nextlink;
281	register char *nextname;	281	char *nextname;
282	unsigned int count;	282	unsigned int count;
283	int lose;	283	int lose;
284	register char **name_vector = 0;	284	char **name_vector = 0;
285	register unsigned int i;	285	unsigned int i;
286	#if defined (OPENDIR_NOT_ROBUST)	286	#if defined (OPENDIR_NOT_ROBUST)
287	struct stat finfo;	287	struct stat finfo;
288		288
Lines 374-380 glob_vector (const char pat, const char dir) Link Here
374	static char **	374	static char **
375	glob_dir_to_array (char dir, char *array)	375	glob_dir_to_array (char dir, char *array)
376	{	376	{
377	register unsigned int i, l;	377	unsigned int i, l;
378	int add_slash;	378	int add_slash;
379	char **result;	379	char **result;
380		380
Lines 454-460 glob_filename (const char *pathname) Link Here
454	if (glob_pattern_p (directory_name))	454	if (glob_pattern_p (directory_name))
455	{	455	{
456	char **directories;	456	char **directories;
457	register unsigned int i;	457	unsigned int i;
458		458
459	if (directory_name[directory_len - 1] == '/')	459	if (directory_name[directory_len - 1] == '/')
460	directory_name[directory_len - 1] = '\0';	460	directory_name[directory_len - 1] = '\0';
Lines 493-499 glob_filename (const char *pathname) Link Here
493	else	493	else
494	{	494	{
495	char **array = glob_dir_to_array (directories[i], temp_results);	495	char **array = glob_dir_to_array (directories[i], temp_results);
496	register unsigned int l;	496	unsigned int l;
497		497
498	l = 0;	498	l = 0;
499	while (array[l] != 0)	499	while (array[l] != 0)
Lines 558-564 glob_filename (const char *pathname) Link Here
558	memory_error:	558	memory_error:
559	if (result != 0)	559	if (result != 0)
560	{	560	{
561	register unsigned int i;	561	unsigned int i;
562	for (i = 0; result[i] != 0; ++i)	562	for (i = 0; result[i] != 0; ++i)
563	free (result[i]);	563	free (result[i]);
564	free ((char *) result);	564	free ((char *) result);

Lines 8698-8706 extern int dddlex (void); Link Here

(-)a/ddd/rxscan.C (-21 / +21 lines)
8698	*/	8698	*/
8699	YY_DECL	8699	YY_DECL
8700	{	8700	{
8701	register ddd_state_type ddd_current_state;	8701	ddd_state_type ddd_current_state;
8702	register char ddd_cp, ddd_bp;	8702	char ddd_cp, ddd_bp;
8703	register int ddd_act;	8703	int ddd_act;
8704		8704
8705	#line 233 "./rxscan.L"	8705	#line 233 "./rxscan.L"
8706		8706
Lines 8748-8754 YY_DECL Link Here
8748	ddd_match:	8748	ddd_match:
8749	do	8749	do
8750	{	8750	{
8751	register YY_CHAR ddd_c = ddd_ec[YY_SC_TO_UI(*ddd_cp)];	8751	YY_CHAR ddd_c = ddd_ec[YY_SC_TO_UI(*ddd_cp)];
8752	if ( ddd_accept[ddd_current_state] )	8752	if ( ddd_accept[ddd_current_state] )
8753	{	8753	{
8754	(ddd_last_accepting_state) = ddd_current_state;	8754	(ddd_last_accepting_state) = ddd_current_state;
Lines 9719-9727 case YY_STATE_EOF(INITIAL): Link Here
9719	*/	9719	*/
9720	static int ddd_get_next_buffer (void)	9720	static int ddd_get_next_buffer (void)
9721	{	9721	{
9722	register char *dest = YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf;	9722	char *dest = YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf;
9723	register char *source = (dddtext_ptr);	9723	char *source = (dddtext_ptr);
9724	register int number_to_move, i;	9724	int number_to_move, i;
9725	int ret_val;	9725	int ret_val;
9726		9726
9727	if ( (ddd_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[(ddd_n_chars) + 1] )	9727	if ( (ddd_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[(ddd_n_chars) + 1] )
Lines 9853-9866 static int ddd_get_next_buffer (void) Link Here
9853		9853
9854	static ddd_state_type ddd_get_previous_state (void)	9854	static ddd_state_type ddd_get_previous_state (void)
9855	{	9855	{
9856	register ddd_state_type ddd_current_state;	9856	ddd_state_type ddd_current_state;
9857	register char *ddd_cp;	9857	char *ddd_cp;
9858		9858
9859	ddd_current_state = (ddd_start);	9859	ddd_current_state = (ddd_start);
9860		9860
9861	for ( ddd_cp = (dddtext_ptr) + YY_MORE_ADJ; ddd_cp < (ddd_c_buf_p); ++ddd_cp )	9861	for ( ddd_cp = (dddtext_ptr) + YY_MORE_ADJ; ddd_cp < (ddd_c_buf_p); ++ddd_cp )
9862	{	9862	{
9863	register YY_CHAR ddd_c = (ddd_cp ? ddd_ec[YY_SC_TO_UI(ddd_cp)] : 3);	9863	YY_CHAR ddd_c = (ddd_cp ? ddd_ec[YY_SC_TO_UI(ddd_cp)] : 3);
9864	if ( ddd_accept[ddd_current_state] )	9864	if ( ddd_accept[ddd_current_state] )
9865	{	9865	{
9866	(ddd_last_accepting_state) = ddd_current_state;	9866	(ddd_last_accepting_state) = ddd_current_state;
Lines 9885-9894 static int ddd_get_next_buffer (void) Link Here
9885	*/	9885	*/
9886	static ddd_state_type ddd_try_NUL_trans (ddd_state_type ddd_current_state )	9886	static ddd_state_type ddd_try_NUL_trans (ddd_state_type ddd_current_state )
9887	{	9887	{
9888	register int ddd_is_jam;	9888	int ddd_is_jam;
9889	register char *ddd_cp = (ddd_c_buf_p);	9889	char *ddd_cp = (ddd_c_buf_p);
9890		9890
9891	register YY_CHAR ddd_c = 3;	9891	YY_CHAR ddd_c = 3;
9892	if ( ddd_accept[ddd_current_state] )	9892	if ( ddd_accept[ddd_current_state] )
9893	{	9893	{
9894	(ddd_last_accepting_state) = ddd_current_state;	9894	(ddd_last_accepting_state) = ddd_current_state;
Lines 9906-9914 static int ddd_get_next_buffer (void) Link Here
9906	return ddd_is_jam ? 0 : ddd_current_state;	9906	return ddd_is_jam ? 0 : ddd_current_state;
9907	}	9907	}
9908		9908
9909	static void dddunput (int c, register char * ddd_bp )	9909	static void dddunput (int c, char * ddd_bp )
9910	{	9910	{
9911	register char *ddd_cp;	9911	char *ddd_cp;
9912		9912
9913	ddd_cp = (ddd_c_buf_p);	9913	ddd_cp = (ddd_c_buf_p);
9914		9914
Lines 9918-9927 static int ddd_get_next_buffer (void) Link Here
9918	if ( ddd_cp < YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf + 2 )	9918	if ( ddd_cp < YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf + 2 )
9919	{ /* need to shift things up to make room */	9919	{ /* need to shift things up to make room */
9920	/* +2 for EOB chars. */	9920	/* +2 for EOB chars. */
9921	register int number_to_move = (ddd_n_chars) + 2;	9921	int number_to_move = (ddd_n_chars) + 2;
9922	register char *dest = &YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[	9922	char *dest = &YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[
9923	YY_CURRENT_BUFFER_LVALUE->ddd_buf_size + 2];	9923	YY_CURRENT_BUFFER_LVALUE->ddd_buf_size + 2];
9924	register char *source =	9924	char *source =
9925	&YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[number_to_move];	9925	&YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf[number_to_move];
9926		9926
9927	while ( source > YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf )	9927	while ( source > YY_CURRENT_BUFFER_LVALUE->ddd_ch_buf )
Lines 10534-10540 int dddlex_destroy (void) Link Here
10534	#ifndef dddtext_ptr	10534	#ifndef dddtext_ptr
10535	static void ddd_flex_strncpy (char* s1, dddconst char * s2, int n )	10535	static void ddd_flex_strncpy (char* s1, dddconst char * s2, int n )
10536	{	10536	{
10537	register int i;	10537	int i;
10538	for ( i = 0; i < n; ++i )	10538	for ( i = 0; i < n; ++i )
10539	s1[i] = s2[i];	10539	s1[i] = s2[i];
10540	}	10540	}
Lines 10543-10549 static void ddd_flex_strncpy (char* s1, dddconst char * s2, int n ) Link Here
10543	#ifdef YY_NEED_STRLEN	10543	#ifdef YY_NEED_STRLEN
10544	static int ddd_flex_strlen (dddconst char * s )	10544	static int ddd_flex_strlen (dddconst char * s )
10545	{	10545	{
10546	register int n;	10546	int n;
10547	for ( n = 0; s[n]; ++n )	10547	for ( n = 0; s[n]; ++n )
10548	;	10548	;
10549		10549

Lines 938-946 extern int vsllex (void); Link Here

(-)a/ddd/vsl-lex.C (-22 / +21 lines)
938	*/	938	*/
939	YY_DECL	939	YY_DECL
940	{	940	{
941	register vsl_state_type vsl_current_state;	941	vsl_state_type vsl_current_state;
942	register char vsl_cp, vsl_bp;	942	char vsl_cp, vsl_bp;
943	register int vsl_act;	943	int vsl_act;
944		944
945	#line 246 "./vsl-lex.L"	945	#line 246 "./vsl-lex.L"
946		946
Lines 990-996 YY_DECL Link Here
990	vsl_match:	990	vsl_match:
991	do	991	do
992	{	992	{
993	register YY_CHAR vsl_c = vsl_ec[YY_SC_TO_UI(*vsl_cp)];	993	YY_CHAR vsl_c = vsl_ec[YY_SC_TO_UI(*vsl_cp)];
994	if ( vsl_accept[vsl_current_state] )	994	if ( vsl_accept[vsl_current_state] )
995	{	995	{
996	(vsl_last_accepting_state) = vsl_current_state;	996	(vsl_last_accepting_state) = vsl_current_state;
Lines 1447-1455 case YY_STATE_EOF(INITIAL): Link Here
1447	*/	1447	*/
1448	static int vsl_get_next_buffer (void)	1448	static int vsl_get_next_buffer (void)
1449	{	1449	{
1450	register char *dest = YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf;	1450	char *dest = YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf;
1451	register char *source = (vsltext_ptr);	1451	char *source = (vsltext_ptr);
1452	register int number_to_move, i;	1452	int number_to_move, i;
1453	int ret_val;	1453	int ret_val;
1454		1454
1455	if ( (vsl_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[(vsl_n_chars) + 1] )	1455	if ( (vsl_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[(vsl_n_chars) + 1] )
Lines 1581-1595 static int vsl_get_next_buffer (void) Link Here
1581		1581
1582	static vsl_state_type vsl_get_previous_state (void)	1582	static vsl_state_type vsl_get_previous_state (void)
1583	{	1583	{
1584	register vsl_state_type vsl_current_state;	1584	vsl_state_type vsl_current_state;
1585	register char *vsl_cp;	1585	char *vsl_cp;
1586		1586
1587	vsl_current_state = (vsl_start);	1587	vsl_current_state = (vsl_start);
1588	vsl_current_state += YY_AT_BOL();	1588	vsl_current_state += YY_AT_BOL();
1589		1589
1590	for ( vsl_cp = (vsltext_ptr) + YY_MORE_ADJ; vsl_cp < (vsl_c_buf_p); ++vsl_cp )	1590	for ( vsl_cp = (vsltext_ptr) + YY_MORE_ADJ; vsl_cp < (vsl_c_buf_p); ++vsl_cp )
1591	{	1591	{
1592	register YY_CHAR vsl_c = (vsl_cp ? vsl_ec[YY_SC_TO_UI(vsl_cp)] : 1);	1592	YY_CHAR vsl_c = (vsl_cp ? vsl_ec[YY_SC_TO_UI(vsl_cp)] : 1);
1593	if ( vsl_accept[vsl_current_state] )	1593	if ( vsl_accept[vsl_current_state] )
1594	{	1594	{
1595	(vsl_last_accepting_state) = vsl_current_state;	1595	(vsl_last_accepting_state) = vsl_current_state;
Lines 1614-1623 static int vsl_get_next_buffer (void) Link Here
1614	*/	1614	*/
1615	static vsl_state_type vsl_try_NUL_trans (vsl_state_type vsl_current_state )	1615	static vsl_state_type vsl_try_NUL_trans (vsl_state_type vsl_current_state )
1616	{	1616	{
1617	register int vsl_is_jam;	1617	int vsl_is_jam;
1618	register char *vsl_cp = (vsl_c_buf_p);	1618	char *vsl_cp = (vsl_c_buf_p);
1619		1619
1620	register YY_CHAR vsl_c = 1;	1620	YY_CHAR vsl_c = 1;
1621	if ( vsl_accept[vsl_current_state] )	1621	if ( vsl_accept[vsl_current_state] )
1622	{	1622	{
1623	(vsl_last_accepting_state) = vsl_current_state;	1623	(vsl_last_accepting_state) = vsl_current_state;
Lines 1635-1643 static int vsl_get_next_buffer (void) Link Here
1635	return vsl_is_jam ? 0 : vsl_current_state;	1635	return vsl_is_jam ? 0 : vsl_current_state;
1636	}	1636	}
1637		1637
1638	static void vslunput (int c, register char * vsl_bp )	1638	static void vslunput (int c, char * vsl_bp )
1639	{	1639	{
1640	register char *vsl_cp;	1640	char *vsl_cp;
1641		1641
1642	vsl_cp = (vsl_c_buf_p);	1642	vsl_cp = (vsl_c_buf_p);
1643		1643
Lines 1647-1656 static int vsl_get_next_buffer (void) Link Here
1647	if ( vsl_cp < YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf + 2 )	1647	if ( vsl_cp < YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf + 2 )
1648	{ /* need to shift things up to make room */	1648	{ /* need to shift things up to make room */
1649	/* +2 for EOB chars. */	1649	/* +2 for EOB chars. */
1650	register int number_to_move = (vsl_n_chars) + 2;	1650	int number_to_move = (vsl_n_chars) + 2;
1651	register char *dest = &YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[	1651	char *dest = &YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[
1652	YY_CURRENT_BUFFER_LVALUE->vsl_buf_size + 2];	1652	YY_CURRENT_BUFFER_LVALUE->vsl_buf_size + 2];
1653	register char *source =	1653	char *source =
1654	&YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[number_to_move];	1654	&YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf[number_to_move];
1655		1655
1656	while ( source > YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf )	1656	while ( source > YY_CURRENT_BUFFER_LVALUE->vsl_ch_buf )
Lines 2265-2271 int vsllex_destroy (void) Link Here
2265	#ifndef vsltext_ptr	2265	#ifndef vsltext_ptr
2266	static void vsl_flex_strncpy (char* s1, vslconst char * s2, int n )	2266	static void vsl_flex_strncpy (char* s1, vslconst char * s2, int n )
2267	{	2267	{
2268	register int i;	2268	int i;
2269	for ( i = 0; i < n; ++i )	2269	for ( i = 0; i < n; ++i )
2270	s1[i] = s2[i];	2270	s1[i] = s2[i];
2271	}	2271	}
Lines 2274-2280 static void vsl_flex_strncpy (char* s1, vslconst char * s2, int n ) Link Here
2274	#ifdef YY_NEED_STRLEN	2274	#ifdef YY_NEED_STRLEN
2275	static int vsl_flex_strlen (vslconst char * s )	2275	static int vsl_flex_strlen (vslconst char * s )
2276	{	2276	{
2277	register int n;	2277	int n;
2278	for ( n = 0; s[n]; ++n )	2278	for ( n = 0; s[n]; ++n )
2279	;	2279	;
2280		2280
2281	-