===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/mandoc/chars.c,v
retrieving revision 1.20
retrieving revision 1.21
diff -c -r1.20 -r1.21
*** src/usr.bin/mandoc/chars.c	2011/05/29 21:26:57	1.20
--- src/usr.bin/mandoc/chars.c	2011/07/08 16:59:50	1.21
***************
*** 1,4 ****
! /*	$Id: chars.c,v 1.20 2011/05/29 21:26:57 schwarze Exp $ */
  /*
   * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
--- 1,4 ----
! /*	$Id: chars.c,v 1.21 2011/07/08 16:59:50 schwarze Exp $ */
  /*
   * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
***************
*** 17,23 ****
   */
  #include <assert.h>
  #include <ctype.h>
- #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  
--- 17,22 ----
***************
*** 48,54 ****
  	struct ln	**htab;
  };
  
- static	inline int	  match(const struct ln *, const char *, size_t);
  static	const struct ln	 *find(struct mchars *, const char *, size_t);
  
  void
--- 47,52 ----
***************
*** 70,77 ****
  	/*
  	 * Constructs a very basic chaining hashtable.  The hash routine
  	 * is simply the integral value of the first character.
! 	 * Subsequent entries are chained in the order they're processed
! 	 * (they're in-line re-ordered during lookup).
  	 */
  
  	tab = mandoc_malloc(sizeof(struct mchars));
--- 68,74 ----
  	/*
  	 * Constructs a very basic chaining hashtable.  The hash routine
  	 * is simply the integral value of the first character.
! 	 * Subsequent entries are chained in the order they're processed.
  	 */
  
  	tab = mandoc_malloc(sizeof(struct mchars));
***************
*** 94,103 ****
  	return(tab);
  }
  
- 
- /* 
-  * Special character to Unicode codepoint.
-  */
  int
  mchars_spec2cp(struct mchars *arg, const char *p, size_t sz)
  {
--- 91,96 ----
***************
*** 109,121 ****
  	return(ln->unicode);
  }
  
- /*
-  * Numbered character string to ASCII codepoint.
-  * This can only be a printable character (i.e., alnum, punct, space) so
-  * prevent the character from ruining our state (backspace, newline, and
-  * so on).
-  * If the character is illegal, returns '\0'.
-  */
  char
  mchars_num2char(const char *p, size_t sz)
  {
--- 102,107 ----
***************
*** 126,135 ****
  	return(i > 0 && i < 256 && isprint(i) ? i : '\0');
  }
  
- /*
-  * Hex character string to Unicode codepoint.
-  * If the character is illegal, returns '\0'.
-  */
  int
  mchars_num2uc(const char *p, size_t sz)
  {
--- 112,117 ----
***************
*** 141,149 ****
  	return(i > 0x80 && i <= 0x10FFFF ? i : '\0');
  }
  
- /* 
-  * Special character to string array.
-  */
  const char *
  mchars_spec2str(struct mchars *arg, const char *p, size_t sz, size_t *rsz)
  {
--- 123,128 ----
***************
*** 162,213 ****
  static const struct ln *
  find(struct mchars *tab, const char *p, size_t sz)
  {
! 	struct ln	 *pp, *prev;
! 	struct ln	**htab;
  	int		  hash;
  
  	assert(p);
- 	if (0 == sz)
- 		return(NULL);
  
! 	if (p[0] < PRINT_LO || p[0] > PRINT_HI)
  		return(NULL);
  
- 	/*
- 	 * Lookup the symbol in the symbol hash.  See ascii2htab for the
- 	 * hashtable specs.  This dynamically re-orders the hash chain
- 	 * to optimise for repeat hits.
- 	 */
- 
  	hash = (int)p[0] - PRINT_LO;
- 	htab = tab->htab;
  
! 	if (NULL == (pp = htab[hash]))
! 		return(NULL);
  
- 	for (prev = NULL; pp; pp = pp->next) {
- 		if ( ! match(pp, p, sz)) {
- 			prev = pp;
- 			continue;
- 		}
- 
- 		if (prev) {
- 			prev->next = pp->next;
- 			pp->next = htab[hash];
- 			htab[hash] = pp;
- 		}
- 
- 		return(pp);
- 	}
- 
  	return(NULL);
- }
- 
- static inline int
- match(const struct ln *ln, const char *p, size_t sz)
- {
- 
- 	if (strncmp(ln->code, p, sz))
- 		return(0);
- 	return('\0' == ln->code[(int)sz]);
  }
--- 141,160 ----
  static const struct ln *
  find(struct mchars *tab, const char *p, size_t sz)
  {
! 	struct ln	 *pp;
  	int		  hash;
  
  	assert(p);
  
! 	if (0 == sz || p[0] < PRINT_LO || p[0] > PRINT_HI)
  		return(NULL);
  
  	hash = (int)p[0] - PRINT_LO;
  
! 	for (pp = tab->htab[hash]; pp; pp = pp->next)
! 		if (0 == strncmp(pp->code, p, sz) && 
! 				'\0' == pp->code[(int)sz])
! 			return(pp);
  
  	return(NULL);
  }