===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/lex/ccl.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -c -r1.7 -r1.8
*** src/usr.bin/lex/ccl.c	2015/11/19 19:43:40	1.7
--- src/usr.bin/lex/ccl.c	2015/11/19 22:55:13	1.8
***************
*** 1,4 ****
! /*	$OpenBSD: ccl.c,v 1.7 2015/11/19 19:43:40 tedu Exp $	*/
  
  /* ccl - routines for character classes */
  
--- 1,4 ----
! /*	$OpenBSD: ccl.c,v 1.8 2015/11/19 22:55:13 tedu Exp $	*/
  
  /* ccl - routines for character classes */
  
***************
*** 10,16 ****
  
  /*  The United States Government has rights in this work pursuant */
  /*  to contract no. DE-AC03-76SF00098 between the United States */
!  /*  Department of Energy and the University of California. */
  
  /*  This file is part of flex. */
  
--- 10,16 ----
  
  /*  The United States Government has rights in this work pursuant */
  /*  to contract no. DE-AC03-76SF00098 between the United States */
!  /* Department of Energy and the University of California. */
  
  /*  This file is part of flex. */
  
***************
*** 37,45 ****
  
  /* return true if the chr is in the ccl. Takes negation into account. */
  static bool
! ccl_contains (const int cclp, const int ch)
  {
! 	int     ind, len, i;
  
  	len = ccllen[cclp];
  	ind = cclmap[cclp];
--- 37,45 ----
  
  /* return true if the chr is in the ccl. Takes negation into account. */
  static bool
! ccl_contains(const int cclp, const int ch)
  {
! 	int ind, len, i;
  
  	len = ccllen[cclp];
  	ind = cclmap[cclp];
***************
*** 48,66 ****
  		if (ccltbl[ind + i] == ch)
  			return !cclng[cclp];
  
!     return cclng[cclp];
  }
  
  
  /* ccladd - add a single character to a ccl */
  
! void    ccladd (cclp, ch)
!      int     cclp;
!      int     ch;
  {
! 	int     ind, len, newpos, i;
  
! 	check_char (ch);
  
  	len = ccllen[cclp];
  	ind = cclmap[cclp];
--- 48,67 ----
  		if (ccltbl[ind + i] == ch)
  			return !cclng[cclp];
  
! 	return cclng[cclp];
  }
  
  
  /* ccladd - add a single character to a ccl */
  
! void 
! ccladd(cclp, ch)
! 	int cclp;
! 	int ch;
  {
! 	int ind, len, newpos, i;
  
! 	check_char(ch);
  
  	len = ccllen[cclp];
  	ind = cclmap[cclp];
***************
*** 82,193 ****
  
  		++num_reallocs;
  
! 		ccltbl = reallocate_Character_array (ccltbl,
! 						     current_max_ccl_tbl_size);
  	}
- 
  	ccllen[cclp] = len + 1;
  	ccltbl[newpos] = ch;
  }
  
  /* dump_cclp - same thing as list_character_set, but for cclps.  */
  
! static void    dump_cclp (FILE* file, int cclp)
  {
  	int i;
  
! 	putc ('[', file);
  
  	for (i = 0; i < csize; ++i) {
! 		if (ccl_contains(cclp, i)){
  			int start_char = i;
  
! 			putc (' ', file);
  
! 			fputs (readable_form (i), file);
  
! 			while (++i < csize && ccl_contains(cclp,i)) ;
  
  			if (i - 1 > start_char)
  				/* this was a run */
! 				fprintf (file, "-%s",
! 					 readable_form (i - 1));
  
! 			putc (' ', file);
  		}
  	}
  
! 	putc (']', file);
  }
  
  
  
  /* ccl_set_diff - create a new ccl as the set difference of the two given ccls. */
  int
! ccl_set_diff (int a, int b)
  {
!     int  d, ch;
  
!     /* create new class  */
!     d = cclinit();
  
!     /* In order to handle negation, we spin through all possible chars,
!      * addding each char in a that is not in b.
!      * (This could be O(n^2), but n is small and bounded.)
!      */
! 	for ( ch = 0; ch < csize; ++ch )
!         if (ccl_contains (a, ch) && !ccl_contains(b, ch))
!             ccladd (d, ch);
  
!     /* debug */
!     if (0){
!         fprintf(stderr, "ccl_set_diff (");
!             fprintf(stderr, "\n    ");
!             dump_cclp (stderr, a);
!             fprintf(stderr, "\n    ");
!             dump_cclp (stderr, b);
!             fprintf(stderr, "\n    ");
!             dump_cclp (stderr, d);
!         fprintf(stderr, "\n)\n");
!     }
!     return d;
  }
  
  /* ccl_set_union - create a new ccl as the set union of the two given ccls. */
  int
! ccl_set_union (int a, int b)
  {
!     int  d, i;
  
!     /* create new class  */
!     d = cclinit();
  
!     /* Add all of a */
!     for (i = 0; i < ccllen[a]; ++i)
! 		ccladd (d, ccltbl[cclmap[a] + i]);
  
!     /* Add all of b */
!     for (i = 0; i < ccllen[b]; ++i)
! 		ccladd (d, ccltbl[cclmap[b] + i]);
  
!     /* debug */
!     if (0){
!         fprintf(stderr, "ccl_set_union (%d + %d = %d", a, b, d);
!             fprintf(stderr, "\n    ");
!             dump_cclp (stderr, a);
!             fprintf(stderr, "\n    ");
!             dump_cclp (stderr, b);
!             fprintf(stderr, "\n    ");
!             dump_cclp (stderr, d);
!         fprintf(stderr, "\n)\n");
!     }
!     return d;
  }
  
  
  /* cclinit - return an empty ccl */
  
! int     cclinit ()
  {
  	if (++lastccl >= current_maxccls) {
  		current_maxccls += MAX_CCLS_INCREMENT;
--- 83,196 ----
  
  		++num_reallocs;
  
! 		ccltbl = reallocate_Character_array(ccltbl,
! 		    current_max_ccl_tbl_size);
  	}
  	ccllen[cclp] = len + 1;
  	ccltbl[newpos] = ch;
  }
  
  /* dump_cclp - same thing as list_character_set, but for cclps.  */
  
! static void 
! dump_cclp(FILE * file, int cclp)
  {
  	int i;
  
! 	putc('[', file);
  
  	for (i = 0; i < csize; ++i) {
! 		if (ccl_contains(cclp, i)) {
  			int start_char = i;
  
! 			putc(' ', file);
  
! 			fputs(readable_form(i), file);
  
! 			while (++i < csize && ccl_contains(cclp, i));
  
  			if (i - 1 > start_char)
  				/* this was a run */
! 				fprintf(file, "-%s",
! 				    readable_form(i - 1));
  
! 			putc(' ', file);
  		}
  	}
  
! 	putc(']', file);
  }
  
  
  
  /* ccl_set_diff - create a new ccl as the set difference of the two given ccls. */
  int
! ccl_set_diff(int a, int b)
  {
! 	int d, ch;
  
! 	/* create new class  */
! 	d = cclinit();
  
! 	/*
! 	 * In order to handle negation, we spin through all possible chars,
! 	 * addding each char in a that is not in b. (This could be O(n^2),
! 	 * but n is small and bounded.)
! 	 */
! 	for (ch = 0; ch < csize; ++ch)
! 		if (ccl_contains(a, ch) && !ccl_contains(b, ch))
! 			ccladd(d, ch);
  
! 	/* debug */
! 	if (0) {
! 		fprintf(stderr, "ccl_set_diff (");
! 		fprintf(stderr, "\n    ");
! 		dump_cclp(stderr, a);
! 		fprintf(stderr, "\n    ");
! 		dump_cclp(stderr, b);
! 		fprintf(stderr, "\n    ");
! 		dump_cclp(stderr, d);
! 		fprintf(stderr, "\n)\n");
! 	}
! 	return d;
  }
  
  /* ccl_set_union - create a new ccl as the set union of the two given ccls. */
  int
! ccl_set_union(int a, int b)
  {
! 	int d, i;
  
! 	/* create new class  */
! 	d = cclinit();
  
! 	/* Add all of a */
! 	for (i = 0; i < ccllen[a]; ++i)
! 		ccladd(d, ccltbl[cclmap[a] + i]);
  
! 	/* Add all of b */
! 	for (i = 0; i < ccllen[b]; ++i)
! 		ccladd(d, ccltbl[cclmap[b] + i]);
  
! 	/* debug */
! 	if (0) {
! 		fprintf(stderr, "ccl_set_union (%d + %d = %d", a, b, d);
! 		fprintf(stderr, "\n    ");
! 		dump_cclp(stderr, a);
! 		fprintf(stderr, "\n    ");
! 		dump_cclp(stderr, b);
! 		fprintf(stderr, "\n    ");
! 		dump_cclp(stderr, d);
! 		fprintf(stderr, "\n)\n");
! 	}
! 	return d;
  }
  
  
  /* cclinit - return an empty ccl */
  
! int 
! cclinit()
  {
  	if (++lastccl >= current_maxccls) {
  		current_maxccls += MAX_CCLS_INCREMENT;
***************
*** 195,221 ****
  		++num_reallocs;
  
  		cclmap =
! 			reallocate_integer_array (cclmap, current_maxccls);
  		ccllen =
! 			reallocate_integer_array (ccllen, current_maxccls);
! 		cclng = reallocate_integer_array (cclng, current_maxccls);
  		ccl_has_nl =
! 			reallocate_bool_array (ccl_has_nl,
! 					       current_maxccls);
  	}
- 
  	if (lastccl == 1)
  		/* we're making the first ccl */
  		cclmap[lastccl] = 0;
  
  	else
! 		/* The new pointer is just past the end of the last ccl.
! 		 * Since the cclmap points to the \first/ character of a
! 		 * ccl, adding the length of the ccl to the cclmap pointer
! 		 * will produce a cursor to the first free space.
  		 */
  		cclmap[lastccl] =
! 			cclmap[lastccl - 1] + ccllen[lastccl - 1];
  
  	ccllen[lastccl] = 0;
  	cclng[lastccl] = 0;	/* ccl's start out life un-negated */
--- 198,224 ----
  		++num_reallocs;
  
  		cclmap =
! 		    reallocate_integer_array(cclmap, current_maxccls);
  		ccllen =
! 		    reallocate_integer_array(ccllen, current_maxccls);
! 		cclng = reallocate_integer_array(cclng, current_maxccls);
  		ccl_has_nl =
! 		    reallocate_bool_array(ccl_has_nl,
! 		    current_maxccls);
  	}
  	if (lastccl == 1)
  		/* we're making the first ccl */
  		cclmap[lastccl] = 0;
  
  	else
! 		/*
! 		 * The new pointer is just past the end of the last ccl.
! 		 * Since the cclmap points to the \first/ character of a ccl,
! 		 * adding the length of the ccl to the cclmap pointer will
! 		 * produce a cursor to the first free space.
  		 */
  		cclmap[lastccl] =
! 		    cclmap[lastccl - 1] + ccllen[lastccl - 1];
  
  	ccllen[lastccl] = 0;
  	cclng[lastccl] = 0;	/* ccl's start out life un-negated */
***************
*** 227,234 ****
  
  /* cclnegate - negate the given ccl */
  
! void    cclnegate (cclp)
!      int     cclp;
  {
  	cclng[cclp] = 1;
  	ccl_has_nl[cclp] = !ccl_has_nl[cclp];
--- 230,238 ----
  
  /* cclnegate - negate the given ccl */
  
! void 
! cclnegate(cclp)
! 	int cclp;
  {
  	cclng[cclp] = 1;
  	ccl_has_nl[cclp] = !ccl_has_nl[cclp];
***************
*** 242,275 ****
   * has a non-zero value in the cset array.
   */
  
! void    list_character_set (file, cset)
!      FILE   *file;
!      int     cset[];
  {
  	int i;
  
! 	putc ('[', file);
  
  	for (i = 0; i < csize; ++i) {
  		if (cset[i]) {
  			int start_char = i;
  
! 			putc (' ', file);
  
! 			fputs (readable_form (i), file);
  
! 			while (++i < csize && cset[i]) ;
  
  			if (i - 1 > start_char)
  				/* this was a run */
! 				fprintf (file, "-%s",
! 					 readable_form (i - 1));
  
! 			putc (' ', file);
  		}
  	}
  
! 	putc (']', file);
  }
  
  /** Determines if the range [c1-c2] is unambiguous in a case-insensitive
--- 246,280 ----
   * has a non-zero value in the cset array.
   */
  
! void 
! list_character_set(file, cset)
! 	FILE *file;
! 	int cset[];
  {
  	int i;
  
! 	putc('[', file);
  
  	for (i = 0; i < csize; ++i) {
  		if (cset[i]) {
  			int start_char = i;
  
! 			putc(' ', file);
  
! 			fputs(readable_form(i), file);
  
! 			while (++i < csize && cset[i]);
  
  			if (i - 1 > start_char)
  				/* this was a run */
! 				fprintf(file, "-%s",
! 				    readable_form(i - 1));
  
! 			putc(' ', file);
  		}
  	}
  
! 	putc(']', file);
  }
  
  /** Determines if the range [c1-c2] is unambiguous in a case-insensitive
***************
*** 283,295 ****
   * @param c2 the upper end of the range
   * @return true if [c1-c2] is not ambiguous for a caseless scanner.
   */
! bool range_covers_case (int c1, int c2)
  {
! 	int     i, o;
  
  	for (i = c1; i <= c2; i++) {
! 		if (has_case (i)) {
! 			o = reverse_case (i);
  			if (o < c1 || c2 < o)
  				return false;
  		}
--- 288,301 ----
   * @param c2 the upper end of the range
   * @return true if [c1-c2] is not ambiguous for a caseless scanner.
   */
! bool 
! range_covers_case(int c1, int c2)
  {
! 	int i, o;
  
  	for (i = c1; i <= c2; i++) {
! 		if (has_case(i)) {
! 			o = reverse_case(i);
  			if (o < c1 || c2 < o)
  				return false;
  		}
***************
*** 300,312 ****
  /** Reverse the case of a character, if possible.
   * @return c if case-reversal does not apply.
   */
! int reverse_case (int c)
  {
! 	return isupper (c) ? tolower (c) : (islower (c) ? toupper (c) : c);
  }
  
  /** Return true if c is uppercase or lowercase. */
! bool has_case (int c)
  {
! 	return (isupper (c) || islower (c)) ? true : false;
  }
--- 306,320 ----
  /** Reverse the case of a character, if possible.
   * @return c if case-reversal does not apply.
   */
! int 
! reverse_case(int c)
  {
! 	return isupper(c) ? tolower(c) : (islower(c) ? toupper(c) : c);
  }
  
  /** Return true if c is uppercase or lowercase. */
! bool 
! has_case(int c)
  {
! 	return (isupper(c) || islower(c)) ? true : false;
  }