===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/mandoc/term.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -c -r1.6 -r1.7
*** src/usr.bin/mandoc/term.c	2009/07/18 20:50:38	1.6
--- src/usr.bin/mandoc/term.c	2009/07/26 00:28:50	1.7
***************
*** 1,4 ****
! /*	$Id: term.c,v 1.6 2009/07/18 20:50:38 schwarze Exp $ */
  /*
   * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
   *
--- 1,4 ----
! /*	$Id: term.c,v 1.7 2009/07/26 00:28:50 schwarze Exp $ */
  /*
   * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
   *
***************
*** 31,45 ****
  
  static	struct termp	 *term_alloc(enum termenc);
  static	void		  term_free(struct termp *);
! static	void		  term_pword(struct termp *, const char *, int);
! static	void		  term_pescape(struct termp *, 
! 				const char *, int *, int);
  static	void		  term_nescape(struct termp *,
  				const char *, size_t);
  static	void		  term_chara(struct termp *, char);
  static	void		  term_encodea(struct termp *, char);
! static	int		  term_isopendelim(const char *, int);
! static	int		  term_isclosedelim(const char *, int);
  
  
  void *
--- 31,43 ----
  
  static	struct termp	 *term_alloc(enum termenc);
  static	void		  term_free(struct termp *);
! static	void		  term_pescape(struct termp *, const char **);
  static	void		  term_nescape(struct termp *,
  				const char *, size_t);
  static	void		  term_chara(struct termp *, char);
  static	void		  term_encodea(struct termp *, char);
! static	int		  term_isopendelim(const char *);
! static	int		  term_isclosedelim(const char *);
  
  
  void *
***************
*** 112,121 ****
  
  
  static int
! term_isclosedelim(const char *p, int len)
  {
  
! 	if (1 != len)
  		return(0);
  
  	switch (*p) {
--- 110,119 ----
  
  
  static int
! term_isclosedelim(const char *p)
  {
  
! 	if ( ! (*p && 0 == *(p + 1)))
  		return(0);
  
  	switch (*p) {
***************
*** 146,155 ****
  
  
  static int
! term_isopendelim(const char *p, int len)
  {
  
! 	if (1 != len)
  		return(0);
  
  	switch (*p) {
--- 144,153 ----
  
  
  static int
! term_isopendelim(const char *p)
  {
  
! 	if ( ! (*p && 0 == *(p + 1)))
  		return(0);
  
  	switch (*p) {
***************
*** 371,420 ****
  
  
  /*
-  * Break apart a word into "pwords" (partial-words, usually from
-  * breaking up a phrase into individual words) and, eventually, put them
-  * into the output buffer.  If we're a literal word, then don't break up
-  * the word and put it verbatim into the output buffer.
-  */
- void
- term_word(struct termp *p, const char *word)
- {
- 	int 		 i, j, len;
- 
- 	len = (int)strlen(word);
- 
- 	if (p->flags & TERMP_LITERAL) {
- 		term_pword(p, word, len);
- 		return;
- 	}
- 
- 	/* LINTED */
- 	for (j = i = 0; i < len; i++) {
- 		if (' ' != word[i]) {
- 			j++;
- 			continue;
- 		} 
- 		
- 		/* Escaped spaces don't delimit... */
- 		if (i && ' ' == word[i] && '\\' == word[i - 1]) {
- 			j++;
- 			continue;
- 		}
- 
- 		if (0 == j)
- 			continue;
- 		assert(i >= j);
- 		term_pword(p, &word[i - j], j);
- 		j = 0;
- 	}
- 	if (j > 0) {
- 		assert(i >= j);
- 		term_pword(p, &word[i - j], j);
- 	}
- }
- 
- 
- /*
   * Determine the symbol indicated by an escape sequences, that is, one
   * starting with a backslash.  Once done, we pass this value into the
   * output buffer by way of the symbol table.
--- 369,374 ----
***************
*** 427,432 ****
--- 381,387 ----
  	int		 i;
  
  	rhs = term_a2ascii(p->symtab, word, len, &sz);
+ 
  	if (rhs)
  		for (i = 0; i < (int)sz; i++) 
  			term_encodea(p, rhs[i]);
***************
*** 439,486 ****
   * the escape sequence (we assert upon badly-formed escape sequences).
   */
  static void
! term_pescape(struct termp *p, const char *word, int *i, int len)
  {
  	int		 j;
  
! 	if (++(*i) >= len)
  		return;
  
! 	if ('(' == word[*i]) {
! 		(*i)++;
! 		if (*i + 1 >= len)
  			return;
  
! 		term_nescape(p, &word[*i], 2);
! 		(*i)++;
  		return;
  
! 	} else if ('*' == word[*i]) { 
! 		(*i)++;
! 		if (*i >= len)
  			return;
  
! 		switch (word[*i]) {
  		case ('('):
! 			(*i)++;
! 			if (*i + 1 >= len)
  				return;
  
! 			term_nescape(p, &word[*i], 2);
! 			(*i)++;
  			return;
  		case ('['):
  			break;
  		default:
! 			term_nescape(p, &word[*i], 1);
  			return;
  		}
  	
! 	} else if ('f' == word[*i]) {
! 		(*i)++;
! 		if (*i >= len)
  			return;
! 		switch (word[*i]) {
  		case ('B'):
  			p->flags |= TERMP_BOLD;
  			break;
--- 394,454 ----
   * the escape sequence (we assert upon badly-formed escape sequences).
   */
  static void
! term_pescape(struct termp *p, const char **word)
  {
  	int		 j;
+ 	const char	*wp;
  
! 	wp = *word;
! 
! 	if (0 == *(++wp)) {
! 		*word = wp;
  		return;
+ 	}
  
! 	if ('(' == *wp) {
! 		wp++;
! 		if (0 == *wp || 0 == *(wp + 1)) {
! 			*word = 0 == *wp ? wp : wp + 1;
  			return;
+ 		}
  
! 		term_nescape(p, wp, 2);
! 		*word = ++wp;
  		return;
  
! 	} else if ('*' == *wp) {
! 		if (0 == *(++wp)) {
! 			*word = wp;
  			return;
+ 		}
  
! 		switch (*wp) {
  		case ('('):
! 			wp++;
! 			if (0 == *wp || 0 == *(wp + 1)) {
! 				*word = 0 == *wp ? wp : wp + 1;
  				return;
+ 			}
  
! 			term_nescape(p, wp, 2);
! 			*word = ++wp;
  			return;
  		case ('['):
  			break;
  		default:
! 			term_nescape(p, wp, 1);
! 			*word = wp;
  			return;
  		}
  	
! 	} else if ('f' == *wp) {
! 		if (0 == *(++wp)) {
! 			*word = wp;
  			return;
! 		}
! 
! 		switch (*wp) {
  		case ('B'):
  			p->flags |= TERMP_BOLD;
  			break;
***************
*** 495,515 ****
  		default:
  			break;
  		}
  		return;
  
! 	} else if ('[' != word[*i]) {
! 		term_nescape(p, &word[*i], 1);
  		return;
  	}
  
! 	(*i)++;
! 	for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
  		/* Loop... */ ;
  
! 	if (0 == word[*i])
  		return;
  
! 	term_nescape(p, &word[*i - j], (size_t)j);
  }
  
  
--- 463,489 ----
  		default:
  			break;
  		}
+ 
+ 		*word = wp;
  		return;
  
! 	} else if ('[' != *wp) {
! 		term_nescape(p, wp, 1);
! 		*word = wp;
  		return;
  	}
  
! 	wp++;
! 	for (j = 0; *wp && ']' != *wp; wp++, j++)
  		/* Loop... */ ;
  
! 	if (0 == *wp) {
! 		*word = wp;
  		return;
+ 	}
  
! 	term_nescape(p, wp - j, (size_t)j);
! 	*word = wp;
  }
  
  
***************
*** 518,529 ****
   * phrase that cannot be broken down (such as a literal string).  This
   * handles word styling.
   */
! static void
! term_pword(struct termp *p, const char *word, int len)
  {
! 	int		 i;
  
! 	if (term_isclosedelim(word, len))
  		if ( ! (TERMP_IGNDELIM & p->flags))
  			p->flags |= TERMP_NOSPACE;
  
--- 492,503 ----
   * phrase that cannot be broken down (such as a literal string).  This
   * handles word styling.
   */
! void
! term_word(struct termp *p, const char *word)
  {
! 	const char	 *sv;
  
! 	if (term_isclosedelim(word))
  		if ( ! (TERMP_IGNDELIM & p->flags))
  			p->flags |= TERMP_NOSPACE;
  
***************
*** 538,550 ****
  	 * before the word.
  	 */
  
! 	for (i = 0; i < len; i++) 
! 		if ('\\' == word[i]) 
! 			term_pescape(p, word, &i, len);
  		else
! 			term_encodea(p, word[i]);
  
! 	if (term_isopendelim(word, len))
  		p->flags |= TERMP_NOSPACE;
  }
  
--- 512,524 ----
  	 * before the word.
  	 */
  
! 	for (sv = word; *word; word++)
! 		if ('\\' != *word)
! 			term_encodea(p, *word);
  		else
! 			term_pescape(p, &word);
  
! 	if (term_isopendelim(sv))
  		p->flags |= TERMP_NOSPACE;
  }
  
***************
*** 575,582 ****
  static void
  term_encodea(struct termp *p, char c)
  {
! 
! 	if (TERMP_STYLE & p->flags) {
  		if (TERMP_BOLD & p->flags) {
  			term_chara(p, c);
  			term_chara(p, 8);
--- 549,556 ----
  static void
  term_encodea(struct termp *p, char c)
  {
! 	
! 	if (' ' != c && TERMP_STYLE & p->flags) {
  		if (TERMP_BOLD & p->flags) {
  			term_chara(p, c);
  			term_chara(p, 8);