isbn 2.0.4 → 2.0.5

data/src/gocr-0.48/src/tga.c

@@ -1,87 +0,0 @@
-/*
-This is a Optical-Character-Recognition program
-Copyright (C) 1999  Joerg Schulenburg
-
-This program is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public License
-as published by the Free Software Foundation; either version 2
-of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
- see README for EMAIL-address
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-
-#include "tga.h"
-
-typedef unsigned char byte;
-
-// --- needed for reading TGA-files
-#if 0
-char read_b(FILE *f1){	// filter #-comments
-  char c;
-  c=fgetc(f1); assert(!feof(f1)); assert(!ferror(f1));
-  return c;
-}
-#endif
-
-//byte tga[18]={ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,24,32};
-/*  header_hex= 00 00 02 00 00 00 00 00 00 00 00 00 xl xh yl yh  
- *              18 20 -- -- -- -- -- -- -- -- -- -- -- -- -- -- */
-
-void readtga(char *name,pix *p,int mode){	 // see pcx.format.txt
-						// mode: 0=gray,1=RGB
-  int nx,ny,i,x,y;
-  FILE *f1;  
-  unsigned char *pic,h[18];
-
-  f1=fopen(name,"rb"); if(!f1) fprintf(stderr," error opening file\n");
-  assert(f1);		// open-error
-  assert(fread(h,1,18,f1)==18);    /* 18 Byte lesen -> h[] */
-  assert(h[ 0]== 0);	// TGA0
-  assert(h[ 1]== 0);	// TGA1
-  assert(h[ 2]== 2);	// TGA2 no run length encoding
-  for(i=3;i<12;i++)
-  assert(h[ i]== 0);	// ???
-  assert(h[16]==0x18);	// TGA16
-  assert(h[17]==0x20);	// TGA17
-  nx = h[12] + (h[13]<<8);  /* x-dimension low high */
-  ny = h[14] + (h[15]<<8);  /* y-dimension low high */
-  fprintf(stderr,"# TGA version=%d x=%d y=%d", h[2],nx,ny );
-  fflush(stdout);
-  pic=(unsigned char *)malloc( 3*nx*ny );
-  assert(pic!=NULL);				// no memory
-  assert(ny==(int)fread(pic,3*nx,ny,f1));	// read all lines BGR
-  if(mode==0)
-  {
-    for(y=0;y<ny;y++)	/* BGR => gray */
-    for(x=0;x<nx;x++)
-    {  i=x+y*nx; pic[i]=(pic[i*3+0]+pic[i*3+1]+pic[i*3+2])/3; }
-  }
-  else
-  if(mode==1)
-  {
-    byte b;
-    for(y=0;y<ny;y++)	/* BGR => RGB */
-    for(x=0;x<nx;x++)
-    {  i=x+y*nx; b=pic[i*3+0]; pic[i*3+0]=pic[i*3+2]; pic[i*3+2]=b; }
-  }
-  else assert(0);		// wrong mode
-  fclose(f1);
-  p->p=pic;  p->x=nx;  p->y=ny; p->bpp=1+2*mode;
-  fprintf(stderr," mode=%d\n",mode);
-}
-
-// ------------------------------------------------------------------------
-

data/src/gocr-0.48/src/tga.h

@@ -1,6 +0,0 @@
-
-#include "pnm.h"
-
-void readtga(char *name,pix *p,int mode); // mode: 0=gray 1=RGB
-
-// ------------------------------------------------------------------------

data/src/gocr-0.48/src/unicode.c

@@ -1,1314 +0,0 @@
-/*
-This is a Optical-Character-Recognition program
-Copyright (C) 2000-2007  Joerg Schulenburg
-
-This program is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public License
-as published by the Free Software Foundation; either version 2
-of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
- see README for EMAIL-address
- */
- 
-#include "unicode.h"
-#include <stdio.h>
-
-/* FIXME jb global */
-int warn=0; /* if 1 a message is generated if composition is not defined */
-
-/* Arguments: the character (main), and the modifier (accent, etc). See the
-      function if you want to know the modifiers. 
-   Description: This function intends to be a small helper, to avoid having
-      to write switches in functions. It's therefore mainly to accents, and
-      specially for the most usual ones. It supports the basic greek 
-      characters too, which is actually not very helpful.
-   Returns: the unicode character corresponding to the composed character.
-   
-   ToDo:
-    - It seems to me, that tables should be more effectiv.
-      So we should use tables in future? (js)
- */
-wchar_t compose(wchar_t main, wchar_t modifier) {
-/* supported by now: part of ISO8859-1, basic greek characters */
-  if( main == UNKNOWN || main == PICTURE ) return main;
-#ifdef DEBUG
-  if(modifier!=UNICODE_NULL && modifier!=SPACE)
-    printf(" compose(%c,%d)",(char)main,(int)modifier);
-#endif
-  if(main>127 && modifier!=0 && modifier!=SPACE && warn)
-    fprintf(stderr,"# Warning compose %04x + %04x>127\n",
-     (int)modifier,(int)main);
-  switch (modifier) {
-    case UNICODE_NULL:
-    case SPACE:
-	return      (wchar_t)main;
-
-    case APOSTROPHE: /* do NOT USE this. It's here for compatibility only.
-			    Use ACUTE_ACCENT instead. */
-      fprintf( stderr, "COMPOSE: got APOSTROPHE instead of ACUTE_ACCENT");
-
-    case ACUTE_ACCENT: /* acute/cedilla */
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_ACUTE;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_ACUTE;
-	case LATIN_SMALL_LETTER_AE:   return LATIN_SMALL_LETTER_AE_WITH_ACUTE;
-	case LATIN_CAPITAL_LETTER_AE: return LATIN_CAPITAL_LETTER_AE_WITH_ACUTE;
-	case 'c':	    return LATIN_SMALL_LETTER_C_WITH_ACUTE;
-	case 'C':	    return LATIN_CAPITAL_LETTER_C_WITH_ACUTE;
-	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_ACUTE;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_ACUTE;
-	case 'g':           return LATIN_SMALL_LETTER_G_WITH_ACUTE;
-	case 'G':           return LATIN_CAPITAL_LETTER_G_WITH_ACUTE;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_ACUTE;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_ACUTE;
-	case 'l':           return LATIN_SMALL_LETTER_L_WITH_ACUTE;
-	case 'L':           return LATIN_CAPITAL_LETTER_L_WITH_ACUTE;
-	case 'n':           return LATIN_SMALL_LETTER_N_WITH_ACUTE;
-	case 'N':           return LATIN_CAPITAL_LETTER_N_WITH_ACUTE;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_ACUTE;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_ACUTE;
-	case '0':	    return LATIN_CAPITAL_LETTER_O_WITH_ACUTE;
-        case 'r':           return LATIN_SMALL_LETTER_R_WITH_ACUTE;
-        case 'R':           return LATIN_CAPITAL_LETTER_R_WITH_ACUTE;
-        case 's':           return LATIN_SMALL_LETTER_S_WITH_ACUTE;
-        case 'S':           return LATIN_CAPITAL_LETTER_S_WITH_ACUTE;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_ACUTE;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_ACUTE;
-	case 'y':	    return LATIN_SMALL_LETTER_Y_WITH_ACUTE;
- 	case 'Y':	    return LATIN_CAPITAL_LETTER_Y_WITH_ACUTE;
-        case 'z':           return LATIN_SMALL_LETTER_Z_WITH_ACUTE;
-        case 'Z':           return LATIN_CAPITAL_LETTER_Z_WITH_ACUTE;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: ACUTE_ACCENT+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case BREVE: /* caron (latin2)  "u"-above-... (small bow) */
-      switch (main) {
-        /* FIXME write separate heuristics for breve */
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_BREVE;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_BREVE;
-	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_BREVE;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_BREVE;
-	case 'g':	    return LATIN_SMALL_LETTER_G_WITH_BREVE;
-	case 'G':	    return LATIN_CAPITAL_LETTER_G_WITH_BREVE;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_BREVE;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_BREVE;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_BREVE;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_BREVE;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_BREVE;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_BREVE;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: BREVE+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case CARON: /* caron (latin2)  "v"-above-... */
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_CARON;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_CARON;
-	case 'c':	    return LATIN_SMALL_LETTER_C_WITH_CARON;
-	case 'C':	    return LATIN_CAPITAL_LETTER_C_WITH_CARON;
-	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_CARON;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_CARON;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_CARON;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_CARON;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_CARON;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_CARON;
-	case '0':	    return LATIN_CAPITAL_LETTER_O_WITH_CARON;
-	case 's':	    return LATIN_SMALL_LETTER_S_WITH_CARON;
-	case 'S':	    return LATIN_CAPITAL_LETTER_S_WITH_CARON;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_CARON;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_CARON;
-	case 'z':	    return LATIN_SMALL_LETTER_Z_WITH_CARON;
-	case 'Z':	    return LATIN_CAPITAL_LETTER_Z_WITH_CARON;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: CARON+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case CEDILLA:
-      switch (main) {
-	case 'c':	    return LATIN_SMALL_LETTER_C_WITH_CEDILLA;
-	case 'C':	    return LATIN_CAPITAL_LETTER_C_WITH_CEDILLA;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: CEDILLA+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case TILDE:
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_TILDE;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_TILDE;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_TILDE;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_TILDE;
-	case 'n':	    return LATIN_SMALL_LETTER_N_WITH_TILDE;
-	case 'N':	    return LATIN_CAPITAL_LETTER_N_WITH_TILDE;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_TILDE;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_TILDE;
-	case '0':	    return LATIN_CAPITAL_LETTER_O_WITH_TILDE;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_TILDE;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_TILDE;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: TILDE+%04x not defined\n",(int)main);
-      }
-      break;
- 
-    case GRAVE_ACCENT:
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_GRAVE;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_GRAVE;
-      	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_GRAVE;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_GRAVE;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_GRAVE;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_GRAVE;
-	case 'n':	    return LATIN_SMALL_LETTER_N_WITH_GRAVE;
-	case 'N':	    return LATIN_CAPITAL_LETTER_N_WITH_GRAVE;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_GRAVE;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_GRAVE;
-	case '0':	    return LATIN_CAPITAL_LETTER_O_WITH_GRAVE;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_GRAVE;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_GRAVE;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: GRAVE_ACCENT+%04x not defined\n",(int)main);
-      }
-      break;
- 
-    case QUOTATION_MARK: /* do NOT USE this. It's here for compatibility only. 
-			    Use DIAERESIS instead. */
-      fprintf( stderr, "COMPOSE: got APOSTROPHE instead of ACUTE_ACCENT");
- 
-    case DIAERESIS:
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_DIAERESIS;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_DIAERESIS;
-	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_DIAERESIS;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_DIAERESIS;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_DIAERESIS;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_DIAERESIS;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_DIAERESIS;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS;
-	case '0':	    return LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_DIAERESIS;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS;
-	case 'y':	    return LATIN_SMALL_LETTER_Y_WITH_DIAERESIS;
-	case 'Y':	    return LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: DIAERESIS+%04x (%c) not defined\n",(int)main,(char)main);
-      }
-      break;
-
-    case CIRCUMFLEX_ACCENT: /* ^ */
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_CIRCUMFLEX;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_CIRCUMFLEX;
-	case 'c':	    return LATIN_SMALL_LETTER_C_WITH_CIRCUMFLEX;
-	case 'C':	    return LATIN_CAPITAL_LETTER_C_WITH_CIRCUMFLEX;
-	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_CIRCUMFLEX;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_CIRCUMFLEX;
-	case 'g':	    return LATIN_SMALL_LETTER_G_WITH_CIRCUMFLEX;
-	case 'G':	    return LATIN_CAPITAL_LETTER_G_WITH_CIRCUMFLEX;
-	case 'h':	    return LATIN_SMALL_LETTER_H_WITH_CIRCUMFLEX;
-	case 'H':	    return LATIN_CAPITAL_LETTER_H_WITH_CIRCUMFLEX;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_CIRCUMFLEX;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_CIRCUMFLEX;
-	case 'j':	    return LATIN_SMALL_LETTER_J_WITH_CIRCUMFLEX;
-	case 'J':	    return LATIN_CAPITAL_LETTER_J_WITH_CIRCUMFLEX;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_CIRCUMFLEX;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_CIRCUMFLEX;
-	case '0':	    return LATIN_CAPITAL_LETTER_O_WITH_CIRCUMFLEX;
-	case 's':	    return LATIN_SMALL_LETTER_S_WITH_CIRCUMFLEX;
-	case 'S':	    return LATIN_CAPITAL_LETTER_S_WITH_CIRCUMFLEX;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_CIRCUMFLEX;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_CIRCUMFLEX;
-	case 'w':	    return LATIN_SMALL_LETTER_W_WITH_CIRCUMFLEX;
-	case 'W':	    return LATIN_CAPITAL_LETTER_W_WITH_CIRCUMFLEX;
-	case 'y':	    return LATIN_SMALL_LETTER_Y_WITH_CIRCUMFLEX;
-	case 'Y':	    return LATIN_CAPITAL_LETTER_Y_WITH_CIRCUMFLEX;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: CIRCUMFLEX_ACCENT+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case MACRON: /* a minus sign above the char (latin2) */
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_MACRON;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_MACRON;
-	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_MACRON;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_MACRON;
-	case 'i':	    return LATIN_SMALL_LETTER_I_WITH_MACRON;
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_MACRON;
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_MACRON;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_MACRON;
-	case 'u':	    return LATIN_SMALL_LETTER_U_WITH_MACRON;
-	case 'U':	    return LATIN_CAPITAL_LETTER_U_WITH_MACRON;
-	case 'y':	    return LATIN_SMALL_LETTER_Y_WITH_MACRON;
-	case 'Y':	    return LATIN_CAPITAL_LETTER_Y_WITH_MACRON;
-	case LATIN_SMALL_LETTER_AE:   return LATIN_SMALL_LETTER_AE_WITH_MACRON;
-	case LATIN_CAPITAL_LETTER_AE: return LATIN_CAPITAL_LETTER_AE_WITH_MACRON;
-	case '=':	    return IDENTICAL_TO;
-	case '-':	    return '=';
-	case ' ':	    return MODIFIER_LETTER_MACRON;
-        default:
-          if(warn)fprintf( stderr, " COMPOSE: MACRON+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case DOT_ABOVE: /* latin2 */
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_DOT_ABOVE;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_DOT_ABOVE;
-	case 'c':	    return LATIN_SMALL_LETTER_C_WITH_DOT_ABOVE;
-	case 'C':	    return LATIN_CAPITAL_LETTER_C_WITH_DOT_ABOVE;
-	case 'e':	    return LATIN_SMALL_LETTER_E_WITH_DOT_ABOVE;
-	case 'E':	    return LATIN_CAPITAL_LETTER_E_WITH_DOT_ABOVE;
-	case 'g':	    return LATIN_SMALL_LETTER_G_WITH_DOT_ABOVE;
-	case 'G':	    return LATIN_CAPITAL_LETTER_G_WITH_DOT_ABOVE;
-	case 'l':	    return 'i';  /* correct wrong recognition */
-	case 'i':	    return 'i';
-	case LATIN_SMALL_LETTER_DOTLESS_I:	    return 'i';
-	case 'I':	    return LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE;
-	case 'j':	    return 'j';
-	case 'o':	    return LATIN_SMALL_LETTER_O_WITH_DOT_ABOVE;
-	case 'O':	    return LATIN_CAPITAL_LETTER_O_WITH_DOT_ABOVE;
-	case 'z':	    return LATIN_SMALL_LETTER_Z_WITH_DOT_ABOVE;
-	case 'Z':	    return LATIN_CAPITAL_LETTER_Z_WITH_DOT_ABOVE;
-	case ',':	    return ';';
-	case '.':	    return ':';
-        default:
-          if(warn)fprintf( stderr, " COMPOSE: DOT_ABOVE+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case RING_ABOVE:
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_A_WITH_RING_ABOVE;
-	case 'A':	    return LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE;
-        case 'u':           return LATIN_SMALL_LETTER_U_WITH_RING_ABOVE;
-        case 'U':           return LATIN_CAPITAL_LETTER_U_WITH_RING_ABOVE;
-        default:
-          if(warn)fprintf( stderr, " COMPOSE: RING_ABOVE+%04x not defined\n",(int)main);
-      }
-      break;
-
-    case 'e': /* e ligatures: ae, oe. */
-    case 'E':
-      switch (main) {
-	case 'a':	    return LATIN_SMALL_LETTER_AE;
-	case 'A':	    return LATIN_CAPITAL_LETTER_AE;
-	case 'o':	    return LATIN_SMALL_LIGATURE_OE;
-	case 'O':	    return LATIN_CAPITAL_LIGATURE_OE;
-	case '0':	    return LATIN_CAPITAL_LIGATURE_OE;
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: %04x+e/E not defined\n",(int)main);
-      }
-      break;
-
-    case 'g': /* greek */
-      switch (main) {
-        /* missing 0x37A-0x390 */
-        /* weird cases: Q -> theta (it resembles a little, doesn't it?)
-			V -> psi   (what can I do?) */
-	case 'A':   return GREEK_CAPITAL_LETTER_ALPHA;
-	case 'B':   return GREEK_CAPITAL_LETTER_BETA;
-	case 'G':   return GREEK_CAPITAL_LETTER_GAMMA;
-	case 'D':   return GREEK_CAPITAL_LETTER_DELTA;
-	case 'E':   return GREEK_CAPITAL_LETTER_EPSILON;
-	case 'Z':   return GREEK_CAPITAL_LETTER_ZETA;
-	case 'H':   return GREEK_CAPITAL_LETTER_ETA;
-	case 'Q':   return GREEK_CAPITAL_LETTER_THETA;
-	case 'I':   return GREEK_CAPITAL_LETTER_IOTA;
-	case 'K':   return GREEK_CAPITAL_LETTER_KAPPA;
-	case 'L':   return GREEK_CAPITAL_LETTER_LAMDA;
-	case 'M':   return GREEK_CAPITAL_LETTER_MU;
-	case 'N':   return GREEK_CAPITAL_LETTER_NU;
-	case 'X':   return GREEK_CAPITAL_LETTER_XI;
-	case 'O':   return GREEK_CAPITAL_LETTER_OMICRON;
-	case 'P':   return GREEK_CAPITAL_LETTER_PI;
-	case 'R':   return GREEK_CAPITAL_LETTER_RHO;
-	case 'S':   return GREEK_CAPITAL_LETTER_SIGMA;
-	case 'T':   return GREEK_CAPITAL_LETTER_TAU;
-	case 'Y':   return GREEK_CAPITAL_LETTER_UPSILON;
-	case 'F':   return GREEK_CAPITAL_LETTER_PHI;
-	case 'C':   return GREEK_CAPITAL_LETTER_CHI;
-	case 'V':   return GREEK_CAPITAL_LETTER_PSI;
-	case 'W':   return GREEK_CAPITAL_LETTER_OMEGA;
-/*
-	case '':   return GREEK_CAPITAL_LETTER_IOTA_WITH_DIALYTIKA;
-	case '':   return GREEK_CAPITAL_LETTER_UPSILON_WITH_DIALYTIKA;
-	case '':   return GREEK_SMALL_LETTER_ALPHA_WITH_TONOS;
-	case '':   return GREEK_SMALL_LETTER_EPSILON_WITH_TONOS;
-	case '':   return GREEK_SMALL_LETTER_ETA_WITH_TONOS;
-	case '':   return GREEK_SMALL_LETTER_IOTA_WITH_TONOS;
-	case '':   return GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA_AND_TONOS;
-*/
-	case 'a':   return GREEK_SMALL_LETTER_ALPHA;
-	case 'b':   return GREEK_SMALL_LETTER_BETA;
-	case 'g':   return GREEK_SMALL_LETTER_GAMMA;
-	case 'd':   return GREEK_SMALL_LETTER_DELTA;
-	case 'e':   return GREEK_SMALL_LETTER_EPSILON;
-	case 'z':   return GREEK_SMALL_LETTER_ZETA;
-	case 'h':   return GREEK_SMALL_LETTER_ETA;
-	case 'q':   return GREEK_SMALL_LETTER_THETA;
-	case 'i':   return GREEK_SMALL_LETTER_IOTA;
-	case 'k':   return GREEK_SMALL_LETTER_KAPPA;
-	case 'l':   return GREEK_SMALL_LETTER_LAMDA;
-	case 'm':   return GREEK_SMALL_LETTER_MU;
-	case 'n':   return GREEK_SMALL_LETTER_NU;
-	case 'x':   return GREEK_SMALL_LETTER_XI;
-	case 'o':   return GREEK_SMALL_LETTER_OMICRON;
-	case 'p':   return GREEK_SMALL_LETTER_PI;
-	case 'r':   return GREEK_SMALL_LETTER_RHO;
-	case '&':   return GREEK_SMALL_LETTER_FINAL_SIGMA;
-	case 's':   return GREEK_SMALL_LETTER_SIGMA;
-	case 't':   return GREEK_SMALL_LETTER_TAU;
-	case 'y':   return GREEK_SMALL_LETTER_UPSILON;
-	case 'f':   return GREEK_SMALL_LETTER_PHI;
-	case 'c':   return GREEK_SMALL_LETTER_CHI;
-	case 'v':   return GREEK_SMALL_LETTER_PSI;
-	case 'w':   return GREEK_SMALL_LETTER_OMEGA;
-/*
-	case '':   return GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA;
-	case '':   return GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA;
-	case '':   return GREEK_SMALL_LETTER_OMICRON_WITH_TONOS;
-	case '':   return GREEK_SMALL_LETTER_UPSILON_WITH_TONOS;
-	case '':   return GREEK_SMALL_LETTER_OMEGA_WITH_TONOS;
-	case '':   return GREEK_BETA_SYMBOL;
-	case '':   return GREEK_THETA_SYMBOL;
-	case '':   return GREEK_UPSILON_WITH_HOOK_SYMBOL;
-	case '':   return GREEK_UPSILON_WITH_ACUTE_AND_HOOK_SYMBOL;
-	case '':   return GREEK_UPSILON_WITH_DIAERESIS_AND_HOOK_SYMBOL;
-	case '':   return GREEK_PHI_SYMBOL;
-	case '':   return GREEK_PI_SYMBOL;
-*/
-	default:
-          if(warn)fprintf( stderr, " COMPOSE: GREEK %04x not defined\n",(int)main);
-      }
-      break;   
-
-    default:
-      fprintf( stderr, " COMPOSE: modifier %04x not defined\n",(int)modifier);
-  }
-  return (wchar_t)main;
-}
-
-#define UNDEFINED			"~"
-
-/* Arguments: character in Unicode format, type of format to convert to.
-   Returns: a string containing the Unicode character converted to the chosen
-    format. This string is statically allocated and should not be freed.
-   ToDo: better using tables?
- */
-const char *decode(wchar_t c, FORMAT type) {
-  /* static char d;  --- js: big bug (missing \0) if &d returned */
-  /*FIXME jb static*/ static char bbuf[8*32]; /* space for 8 buffers, rotating */
-  /*FIXME jb static*/ static char *buf=bbuf;  /* used for UTF8 sequences and undefined codes */
-  buf+=32; if(buf>=bbuf+8*32) buf=bbuf;
-  buf[0]=buf[1]=buf[2]=0;
-  switch (type) {
-    case ISO8859_1:
-      if ( c <= 0xFF ) { /* UNICODE == ISO8859-1 */
-        buf[0] = (char)c;
-        return buf;
-      }
-      switch (c) { /* not found in list, but perhaps we can describe it */
-	/* todo: add greek. GREEK_SMALL_LETTER_ALPHA = alpha */
-	
-	/* general puctuation */
-	case HYPHEN:
-	  return (const char *)"-";
-	case FIGURE_DASH:
-	case EN_DASH:
-	  return (const char *)"--";
-	case EM_DASH:
-	  return (const char *)"---";
-	case LEFT_SINGLE_QUOTATION_MARK:
-	  return (const char *)"`";
-	case RIGHT_SINGLE_QUOTATION_MARK:
-	  return (const char *)"'";
-	case SINGLE_LOW_9_QUOTATION_MARK:
-	  return (const char *)",";
-	case SINGLE_HIGH_REVERSED_9_QUOTATION_MARK:
-	  return (const char *)UNDEFINED;
-	case LEFT_DOUBLE_QUOTATION_MARK:
-	  return (const char *)"``";
-	case RIGHT_DOUBLE_QUOTATION_MARK:
-	  return (const char *)"''";
-	case DOUBLE_LOW_9_QUOTATION_MARK:
-	  return (const char *)",,";
-	case DOUBLE_HIGH_REVERSED_9_QUOTATION_MARK:
-	  return (const char *)UNDEFINED;
-	case DAGGER:
-	  return (const char *)"+";
-	case DOUBLE_DAGGER:
-	  return (const char *)"*";
-	case BULLET:
-	  return (const char *)"*";
-	case TRIANGULAR_BULLET:
-	  return (const char *)"*";
-	case HYPHENATION_POINT:
-	  return (const char *)"-";
-	case HORIZONTAL_ELLIPSIS:
-	  return (const char *)"...";
-	case PER_MILLE_SIGN:
-	  return (const char *)"%%"; /* awk! */
-	case SINGLE_LEFT_POINTING_ANGLE_QUOTATION_MARK:
-	  return (const char *)"<";
-	case SINGLE_RIGHT_POINTING_ANGLE_QUOTATION_MARK:
-	  return (const char *)">";
-	case EURO_CURRENCY_SIGN:
-	  return (const char *)"EUR"; /* change it! */
-	
-	/* ligatures */
-	case LATIN_SMALL_LIGATURE_FF:
-	  return (const char *)"ff";
-	case LATIN_SMALL_LIGATURE_FI:
-	  return (const char *)"fi";
-	case LATIN_SMALL_LIGATURE_FL:
-	  return (const char *)"fl";
-	case LATIN_SMALL_LIGATURE_FFI:
-	  return (const char *)"ffi";
-	case LATIN_SMALL_LIGATURE_FFL:
-	  return (const char *)"ffl";
-	case LATIN_SMALL_LIGATURE_LONG_S_T:
-	case LATIN_SMALL_LIGATURE_ST:
-	  return (const char *)"st";
-	
-	/* extra */
-	case UNKNOWN:
-	  return (const char *)"_";
-	case PICTURE:
-	  return (const char *)"_"; /* Due to Mobile OCR */
-		
-	default:
-	  /* snprintf seems to be no standard, so I use insecure sprintf */
-	  sprintf(buf,"\\code(%04x)",(unsigned)c);
-	  return buf;  /* UNDEFINED; */
-      }
-      break;
-    case TeX:
-      if ( c >= SPACE && c <= TILDE ) { /* ASCII */
-	switch (c) {
-	  case '$':
-	      return (const char *)"\\$";
-	  case '&':
-	      return (const char *)"\\&";
-	  case '%':
-	      return (const char *)"\\%";
-	  case '#':
-	      return (const char *)"\\#";
-	  case '_':
-	      return (const char *)"\\_";
-	  case '{':
-	      return (const char *)"\\{";
-	  case '}':
-	      return (const char *)"\\}";
-	  case '\\':
-	      return (const char *)"$\\backslash$";
-	  case '~':
-	      return (const char *)"\\~{}";
-	  case '^':
-	      return (const char *)"\\^{}";
-	  default:
-	      buf[0] = (char)c;
-	      return (const char *)buf;
-	}
-      }
-      switch (c) {
-	/* ISO8859_1 */
-	case NO_BREAK_SPACE:
-	  return (const char *)"~";
-	case INVERTED_EXCLAMATION_MARK:
-	  return (const char *)"!'";
-	case CENT_SIGN:
-	  return (const char *)"\\textcent"; /* \usepackage{textcomp} */
-	case POUND_SIGN:
-	  return (const char *)"\\pounds";
-	case EURO_CURRENCY_SIGN:
-	  return (const char *)"\\euro"; /* \usepackage{eurosans} */
-	case CURRENCY_SIGN:
-	  return (const char *)"\\textcurrency"; /* \usepackage{textcomp} */
-	case YEN_SIGN:
-	  return (const char *)"\\textyen"; /* \usepackage{textcomp} */
-	case BROKEN_BAR:
-	  return (const char *)"\\textbrokenbar"; /* \usepackage{textcomp} */
-	case SECTION_SIGN:
-	  return (const char *)"\\S";
-	case DIAERESIS:
-	  return (const char *)"\"";
-	case COPYRIGHT_SIGN:
-	  return (const char *)"\\copyright";
-	case FEMININE_ORDINAL_INDICATOR:
-	  return (const char *)"$^{\\underbar{a}}$";
-	case LEFT_POINTING_DOUBLE_ANGLE_QUOTATION_MARK:
-	  return (const char *)"\\flqq{}";
-	case NOT_SIGN:
-	  return (const char *)"$\\lnot$";
-	case SOFT_HYPHEN:
-	  return (const char *)"\\-";
-	case REGISTERED_SIGN:
-	  return (const char *)"\\textregistered";/* \usepackage{textcomp} */
-	case MACRON:
-	  return (const char *)"\\textasciimacron";/* \usepackage{textcomp} */
-	case DEGREE_SIGN:
-	  return (const char *)"$^{o}$";
-	case PLUS_MINUS_SIGN:
-	  return (const char *)"$\\pm$";
-	case SUPERSCRIPT_TWO:
-	  return (const char *)"$^{2}$";
-	case SUPERSCRIPT_THREE:
-	  return (const char *)"$^{3}$";
-	case ACUTE_ACCENT:
-	  return (const char *)"\\( \\prime \\)";
-	case MICRO_SIGN:
-	  return (const char *)"$\\mu$";
-	case PILCROW_SIGN:
-	  return (const char *)"\\P";
-	case MIDDLE_DOT:
-	  return (const char *)"$\\cdot$";
-	case CEDILLA:
-	  return (const char *)"\\,";
-	case SUPERSCRIPT_ONE:
-	  return (const char *)"$^{1}$";
-	case MASCULINE_ORDINAL_INDICATOR:
-	  return (const char *)"$^{\\underbar{o}}$";
-	case RIGHT_POINTING_DOUBLE_ANGLE_QUOTATION_MARK:
-	  return (const char *)"\\frqq{}";
-	case VULGAR_FRACTION_ONE_QUARTER:	 /* these fractions are not good*/
-	  return (const char *)"\\( 1\\over 4 \\)";
-	case VULGAR_FRACTION_ONE_HALF:
-	  return (const char *)"\\( 1\\over 2 \\)";
-	case VULGAR_FRACTION_THREE_QUARTERS:
-	  return (const char *)"\\( 3\\over 4 \\)";
-	case INVERTED_QUESTION_MARK:
-	  return (const char *)"?'";
-	case LATIN_CAPITAL_LETTER_A_WITH_GRAVE:
-	  return (const char *)"\\`A";
-	case LATIN_CAPITAL_LETTER_A_WITH_ACUTE:
-	  return (const char *)"\\'A";
-	case LATIN_CAPITAL_LETTER_A_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^A";
-	case LATIN_CAPITAL_LETTER_A_WITH_TILDE:
-	  return (const char *)"\\~A";
-	case LATIN_CAPITAL_LETTER_A_WITH_DIAERESIS:
-	  return (const char *)"\\\"A";
-	case LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE:
-	  return (const char *)"\\AA";
-	case LATIN_CAPITAL_LETTER_AE:
-	  return (const char *)"\\AE";
-	case LATIN_CAPITAL_LETTER_C_WITH_CARON:
-	  return (const char *)"\\v{C}";
-	case LATIN_CAPITAL_LETTER_C_WITH_CEDILLA:
-	  return (const char *)"\\C";
-	case LATIN_CAPITAL_LETTER_E_WITH_GRAVE:
-	  return (const char *)"\\`E";
-	case LATIN_CAPITAL_LETTER_E_WITH_ACUTE:
-	  return (const char *)"\\'E";
-	case LATIN_CAPITAL_LETTER_E_WITH_CARON:
-	  return (const char *)"\\v{E}";
-	case LATIN_CAPITAL_LETTER_E_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^E";
-	case LATIN_CAPITAL_LETTER_E_WITH_DIAERESIS:
-	  return (const char *)"\\\"E";
-	case LATIN_CAPITAL_LETTER_I_WITH_GRAVE:
-	  return (const char *)"\\`I";
-	case LATIN_CAPITAL_LETTER_I_WITH_ACUTE:
-	  return (const char *)"\\'I";
-	case LATIN_CAPITAL_LETTER_I_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^I";
-	case LATIN_CAPITAL_LETTER_I_WITH_DIAERESIS:
-	  return (const char *)"\\\"I";
-	case LATIN_CAPITAL_LETTER_ETH:
-	  return (const char *)UNDEFINED;
-	case LATIN_CAPITAL_LETTER_N_WITH_TILDE:
-	  return (const char *)"\\~N";
-	case LATIN_CAPITAL_LETTER_O_WITH_GRAVE:
-	  return (const char *)"\\`O";
-	case LATIN_CAPITAL_LETTER_O_WITH_ACUTE:
-	  return (const char *)"\\'O";
-	case LATIN_CAPITAL_LETTER_O_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^O";
-	case LATIN_CAPITAL_LETTER_O_WITH_TILDE:
-	  return (const char *)"\\~O";
-	case LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS:
-	  return (const char *)"\\\"O";
-	case MULTIPLICATION_SIGN:
-	  return (const char *)"$\\times$";
-	case LATIN_CAPITAL_LETTER_O_WITH_STROKE:
-	  return (const char *)"\\O";
-	case LATIN_CAPITAL_LETTER_S_WITH_CARON:
-	  return (const char *)"\\v{S}";
-	case LATIN_CAPITAL_LETTER_U_WITH_GRAVE:
-	  return (const char *)"\\`U";
-	case LATIN_CAPITAL_LETTER_U_WITH_ACUTE:
-	  return (const char *)"\\'U";
-	case LATIN_CAPITAL_LETTER_U_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^U";
-	case LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS:
-	  return (const char *)"\\\"U";
-	case LATIN_CAPITAL_LETTER_Y_WITH_ACUTE:
-	  return (const char *)"\\'Y";
-	case LATIN_CAPITAL_LETTER_Z_WITH_CARON:
-	  return (const char *)"\\v{Z}";
-	case LATIN_CAPITAL_LETTER_THORN:
-	  return (const char *)UNDEFINED;
-	case LATIN_SMALL_LETTER_SHARP_S:
-	  return (const char *)"\\ss";
-	case LATIN_SMALL_LETTER_A_WITH_GRAVE:
-	  return (const char *)"\\`a";
-	case LATIN_SMALL_LETTER_A_WITH_ACUTE:
-	  return (const char *)"\\'a";
-	case LATIN_SMALL_LETTER_A_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^a";
-	case LATIN_SMALL_LETTER_A_WITH_TILDE:
-	  return (const char *)"\\~a";
-	case LATIN_SMALL_LETTER_A_WITH_DIAERESIS:
-	  return (const char *)"\\\"a";
-	case LATIN_SMALL_LETTER_A_WITH_RING_ABOVE:
-	  return (const char *)"\\aa";
-	case LATIN_SMALL_LETTER_AE:
-	  return (const char *)"\\ae";
-	case LATIN_SMALL_LETTER_C_WITH_CARON:
-	  return (const char *)"\\v{c}";
-	case LATIN_SMALL_LETTER_C_WITH_CEDILLA:
-	  return (const char *)"\\c";
-	case LATIN_SMALL_LETTER_E_WITH_GRAVE:
-	  return (const char *)"\\`e";
-	case LATIN_SMALL_LETTER_E_WITH_ACUTE:
-	  return (const char *)"\\'e";
-	case LATIN_SMALL_LETTER_E_WITH_CARON:
-	  return (const char *)"\\v{e}";
-	case LATIN_SMALL_LETTER_E_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^e";
-	case LATIN_SMALL_LETTER_E_WITH_DIAERESIS:
-	  return (const char *)"\\\"e";
-	case LATIN_SMALL_LETTER_I_WITH_GRAVE:
-	  return (const char *)"\\`i";
-	case LATIN_SMALL_LETTER_I_WITH_ACUTE:
-	  return (const char *)"\\'i";
-	case LATIN_SMALL_LETTER_I_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^i";
-	case LATIN_SMALL_LETTER_I_WITH_DIAERESIS:
-	  return (const char *)"\\\"i";
-	case LATIN_SMALL_LETTER_ETH:
-	  return (const char *)UNDEFINED;
-	case LATIN_SMALL_LETTER_N_WITH_TILDE:
-	  return (const char *)"\\~n";
-	case LATIN_SMALL_LETTER_O_WITH_GRAVE:
-	  return (const char *)"\\`o";
-	case LATIN_SMALL_LETTER_O_WITH_ACUTE:
-	  return (const char *)"\\'o";
-	case LATIN_SMALL_LETTER_O_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^o";
-	case LATIN_SMALL_LETTER_O_WITH_TILDE:
-	  return (const char *)"\\~o";
-	case LATIN_SMALL_LETTER_O_WITH_DIAERESIS:
-	  return (const char *)"\\\"o";
-	case DIVISION_SIGN:
-	  return (const char *)"$\\div$";
-	case LATIN_SMALL_LETTER_O_WITH_STROKE:
-	  return (const char *)"\\o";
-	case LATIN_SMALL_LETTER_S_WITH_CARON:
-	  return (const char *)"\\v{s}";
-	case LATIN_SMALL_LETTER_U_WITH_GRAVE:
-	  return (const char *)"\\`u";
-	case LATIN_SMALL_LETTER_U_WITH_ACUTE:
-	  return (const char *)"\\'u";
-	case LATIN_SMALL_LETTER_U_WITH_CIRCUMFLEX:
-	  return (const char *)"\\^u";
-	case LATIN_SMALL_LETTER_U_WITH_DIAERESIS:
-	  return (const char *)"\\\"u";
-	case LATIN_SMALL_LETTER_Y_WITH_ACUTE:
-	  return (const char *)"\\'y";
-	case LATIN_SMALL_LETTER_THORN:
-	  return (const char *)UNDEFINED;
-	case LATIN_SMALL_LETTER_Y_WITH_DIAERESIS:
-	  return (const char *)"\\\"y";
-	case LATIN_SMALL_LETTER_Z_WITH_CARON:
-	  return (const char *)"\\v{z}";
-
-	/* greek */
-	  /* some (punctuation, accents, accented capital) greek letters missing*/
-	case GREEK_CAPITAL_LETTER_ALPHA:
-	  return (const char *)"A";
-	case GREEK_CAPITAL_LETTER_BETA:
-	  return (const char *)"B";
-	case GREEK_CAPITAL_LETTER_GAMMA:
-	  return (const char *)"\\( \\Gamma \\)";
-	case GREEK_CAPITAL_LETTER_DELTA:
-	  return (const char *)"\\( \\Delta \\)";
-	case GREEK_CAPITAL_LETTER_EPSILON:
-	  return (const char *)"E";
-	case GREEK_CAPITAL_LETTER_ZETA:
-	  return (const char *)"Z";
-	case GREEK_CAPITAL_LETTER_ETA:
-	  return (const char *)"H";
-	case GREEK_CAPITAL_LETTER_THETA:
-	  return (const char *)"\\( \\Theta \\)";
-	case GREEK_CAPITAL_LETTER_IOTA:
-	  return (const char *)"I";
-	case GREEK_CAPITAL_LETTER_KAPPA:
-	  return (const char *)"K";
-	case GREEK_CAPITAL_LETTER_LAMDA:
-	  return (const char *)"\\( \\Lambda \\)";
-	case GREEK_CAPITAL_LETTER_MU:
-	  return (const char *)"M";
-	case GREEK_CAPITAL_LETTER_NU:
-	  return (const char *)"N";
-	case GREEK_CAPITAL_LETTER_XI:
-	  return (const char *)"\\( \\Xi \\)";
-	case GREEK_CAPITAL_LETTER_OMICRON:
-	  return (const char *)"O";
-	case GREEK_CAPITAL_LETTER_PI:
-	  return (const char *)"\\( \\Pi \\)";
-	case GREEK_CAPITAL_LETTER_RHO:
-	  return (const char *)"P";
-	case GREEK_CAPITAL_LETTER_SIGMA:
-	  return (const char *)"\\( \\Sigma \\)";
-	case GREEK_CAPITAL_LETTER_TAU:
-	  return (const char *)"T";
-	case GREEK_CAPITAL_LETTER_UPSILON:
-	  return (const char *)"\\( \\Upsilon \\)";
-	case GREEK_CAPITAL_LETTER_PHI:
-	  return (const char *)"\\( \\Phi \\)";
-	case GREEK_CAPITAL_LETTER_CHI:
-	  return (const char *)"\\( \\Chi \\)";
-	case GREEK_CAPITAL_LETTER_PSI:
-	  return (const char *)"\\( \\Psi \\)";
-	case GREEK_CAPITAL_LETTER_OMEGA:
-	  return (const char *)"\\( \\Omega \\)";
-	case GREEK_CAPITAL_LETTER_IOTA_WITH_DIALYTIKA:
-	  return (const char *)UNDEFINED;
-	case GREEK_CAPITAL_LETTER_UPSILON_WITH_DIALYTIKA:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_ALPHA_WITH_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_EPSILON_WITH_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_ETA_WITH_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_IOTA_WITH_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA_AND_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_ALPHA:
-	  return (const char *)"\\( \\alpha \\)";
-	case GREEK_SMALL_LETTER_BETA:
-	  return (const char *)"\\( \\beta \\)";
-	case GREEK_SMALL_LETTER_GAMMA:
-	  return (const char *)"\\( \\gamma \\)";
-	case GREEK_SMALL_LETTER_DELTA:
-	  return (const char *)"\\( \\delta \\)";
-	case GREEK_SMALL_LETTER_EPSILON:
-	  return (const char *)"\\( \\epsilon \\)";
-	case GREEK_SMALL_LETTER_ZETA:
-	  return (const char *)"\\( \\zeta \\)";
-	case GREEK_SMALL_LETTER_ETA:
-	  return (const char *)"\\( \\eta \\)";
-	case GREEK_SMALL_LETTER_THETA:
-	  return (const char *)"\\( \\theta \\)";
-	case GREEK_SMALL_LETTER_IOTA:
-	  return (const char *)"\\( \\iota \\)";
-	case GREEK_SMALL_LETTER_KAPPA:
-	  return (const char *)"\\( \\kappa \\)";
-	case GREEK_SMALL_LETTER_LAMDA:
-	  return (const char *)"\\( \\lambda \\)";
-	case GREEK_SMALL_LETTER_MU:
-	  return (const char *)"\\( \\mu \\)";
-	case GREEK_SMALL_LETTER_NU:
-	  return (const char *)"\\( \\nu \\)";
-	case GREEK_SMALL_LETTER_XI:
-	  return (const char *)"\\( \\xi \\)";
-	case GREEK_SMALL_LETTER_OMICRON:
-	  return (const char *)"\\( \\omicron \\)";
-	case GREEK_SMALL_LETTER_PI:
-	  return (const char *)"\\( \\pi \\)";
-	case GREEK_SMALL_LETTER_RHO:
-	  return (const char *)"\\( \\rho \\)";
-	case GREEK_SMALL_LETTER_FINAL_SIGMA:
-	  return (const char *)"\\( \\varsigma \\)";
-	case GREEK_SMALL_LETTER_SIGMA:
-	  return (const char *)"\\( \\sigma \\)";
-	case GREEK_SMALL_LETTER_TAU:
-	  return (const char *)"\\( \\tau \\)";
-	case GREEK_SMALL_LETTER_UPSILON:
-	  return (const char *)"\\( \\upsilon \\)";
-	case GREEK_SMALL_LETTER_PHI:
-	  return (const char *)"\\( \\varphi \\)";
-	case GREEK_SMALL_LETTER_CHI:
-	  return (const char *)"\\( \\chi \\)";
-	case GREEK_SMALL_LETTER_PSI:
-	  return (const char *)"\\( \\psi \\)";
-	case GREEK_SMALL_LETTER_OMEGA:
-	  return (const char *)"\\( \\omega \\)";
-	case GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_OMICRON_WITH_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_UPSILON_WITH_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_SMALL_LETTER_OMEGA_WITH_TONOS:
-	  return (const char *)UNDEFINED;
-	case GREEK_BETA_SYMBOL:
-	  return (const char *)UNDEFINED;
-	case GREEK_THETA_SYMBOL:
-	  return (const char *)"\\( \\vartheta \\)";
-	case GREEK_UPSILON_WITH_HOOK_SYMBOL:
-	  return (const char *)UNDEFINED;
-	case GREEK_UPSILON_WITH_ACUTE_AND_HOOK_SYMBOL:
-	  return (const char *)UNDEFINED;
-	case GREEK_UPSILON_WITH_DIAERESIS_AND_HOOK_SYMBOL:
-	  return (const char *)UNDEFINED;
-	case GREEK_PHI_SYMBOL:
-	  return (const char *)"\\( \\phi \\)";
-	case GREEK_PI_SYMBOL:
-	  return (const char *)"\\( \\varpi \\)";
-	  /* and some greek letters missing*/
-
-	/* punctuation (partial) */
-	case HYPHEN:
-	  return (const char *)"-";
-	case NON_BREAKING_HYPHEN:
-	  return (const char *)UNDEFINED;
-	case FIGURE_DASH:
-	case EN_DASH:
-	  return (const char *)"--";
-	case EM_DASH:
-	  return (const char *)"---";
-	case HORIZONTAL_BAR:
-	  return (const char *)UNDEFINED;
-	case LEFT_SINGLE_QUOTATION_MARK:
-	  return (const char *)"`";
-	case RIGHT_SINGLE_QUOTATION_MARK:
-	  return (const char *)"'";
-	case SINGLE_LOW_9_QUOTATION_MARK:
-	  return (const char *)"\\glq{}";
-	case SINGLE_HIGH_REVERSED_9_QUOTATION_MARK:
-	  return (const char *)UNDEFINED;
-	case LEFT_DOUBLE_QUOTATION_MARK:
-	  return (const char *)"``";
-	case RIGHT_DOUBLE_QUOTATION_MARK:
-	  return (const char *)"''";
-	case DOUBLE_LOW_9_QUOTATION_MARK:
-	  return (const char *)"\\glqq{}";
-	case DOUBLE_HIGH_REVERSED_9_QUOTATION_MARK:
-	  return (const char *)UNDEFINED;
-	case DAGGER:
-	  return (const char *)"\\dag";
-	case DOUBLE_DAGGER:
-	  return (const char *)"\\ddag";
-	case BULLET:
-	  return (const char *)"$\\bullet$";
-	case TRIANGULAR_BULLET:
-	  return (const char *)"$\\blacktriangleright";
-	case HYPHENATION_POINT:
-	  return (const char *)"\\-";
-	case HORIZONTAL_ELLIPSIS:
-	  return (const char *)"\\ldots";
-	case PER_MILLE_SIGN:
-	  return (const char *)UNDEFINED;
-	case SINGLE_LEFT_POINTING_ANGLE_QUOTATION_MARK:
-	  return (const char *)"\\flq{}";
-	case SINGLE_RIGHT_POINTING_ANGLE_QUOTATION_MARK:
-	  return (const char *)"\\frq{}";
-	/* ligatures */
-	case LATIN_SMALL_LIGATURE_FF:
-	  return (const char *)"ff";
-	case LATIN_SMALL_LIGATURE_FI:
-	  return (const char *)"fi";
-	case LATIN_SMALL_LIGATURE_FL:
-	  return (const char *)"fl";
-	case LATIN_SMALL_LIGATURE_FFI:
-	  return (const char *)"ffi";
-	case LATIN_SMALL_LIGATURE_FFL:
-	  return (const char *)"ffl";
-	case LATIN_SMALL_LIGATURE_LONG_S_T:
-	case LATIN_SMALL_LIGATURE_ST:
-	  return (const char *)"st";
-	/* reserved */
-	case 0:
-	  return (const char *)"";
-	case UNKNOWN:
-	  return (const char *)"\\_";
-	case PICTURE:
-	  return (const char *)"(PICTURE)";
-	default:
-	  /* snprintf seems to be no standard, so I use insecure sprintf */
-	  sprintf(buf,"\\symbol{%u}",(unsigned)c);
-	  return buf;  /* UNDEFINED; */
-	}
-    case HTML:
-      if ( c >= SPACE && c <= TILDE ) { /* ASCII */
-        switch (c) {
-          case '&':
-            return (const char *)"&amp;";
-          /* semicolon must not be coded */
-          case '\'':
-            return (const char *)"&apos;";
-          case '"':
-            return (const char *)"&quot;";
-          case '<':
-            return (const char *)"&lt;";
-          case '>':
-            return (const char *)"&gt;";
-        }
-        buf[0] = (char)c;
-        return buf;
-      }
-      switch (c) {
-	case PICTURE:
-	  return (const char *)"<!--PICTURE-->";
-        case UNKNOWN:
-          return (const char *)"_"; /* better use colored symbol? */
-        case LINE_FEED:
-          return (const char *)"<br />";  /* \n handled somwhere else? */
-	case FORM_FEED:
-	case CARRIAGE_RETURN:
-	  return (const char *)"<br />";
-	case NO_BREAK_SPACE:
-	  return (const char *)"<nobr />";
-	case INVERTED_EXCLAMATION_MARK:
-	  return (const char *)"&iexcl;";
-	case CENT_SIGN:
-	  return (const char *)"&cent;";
-	case POUND_SIGN:
-	  return (const char *)"&pound;";
-	case CURRENCY_SIGN:
-	  return (const char *)"&curren;";
-	case YEN_SIGN:
-	  return (const char *)"&yen;";
-	case BROKEN_BAR:
-	  return (const char *)"&brvbar;";
-	case SECTION_SIGN:
-	  return (const char *)"&sect;";
-	case DIAERESIS:
-	  return (const char *)"&uml;";
-	case COPYRIGHT_SIGN:
-	  return (const char *)"&copy;";
-	case FEMININE_ORDINAL_INDICATOR:
-	  return (const char *)"&ordfem;";
-	case LEFT_POINTING_DOUBLE_ANGLE_QUOTATION_MARK:
-	  return (const char *)"&laquo;";
-	case NOT_SIGN:
-	  return (const char *)"&not;";
-	case SOFT_HYPHEN:
-	  return (const char *)"&shy;";
-	case REGISTERED_SIGN:
-	  return (const char *)"&reg;";
-	case MACRON:
-	  return (const char *)"&macr;";
-	case DEGREE_SIGN:
-	  return (const char *)"&deg;";
-	case PLUS_MINUS_SIGN:
-	  return (const char *)"&plusmn;";
-	case SUPERSCRIPT_TWO:
-	  return (const char *)"&sup2;";
-	case SUPERSCRIPT_THREE:
-	  return (const char *)"&sup3;";
-	case ACUTE_ACCENT:
-	  return (const char *)"&acute;";
-	case MICRO_SIGN:
-	  return (const char *)"&micro;";
-	case PILCROW_SIGN:
-	  return (const char *)"&para;";
-	case MIDDLE_DOT:
-	  return (const char *)"&middot;";
-	case CEDILLA:
-	  return (const char *)"&cedil;";
-	case SUPERSCRIPT_ONE:
-	  return (const char *)"&sup1;";
-	case MASCULINE_ORDINAL_INDICATOR:
-	  return (const char *)"&ordm;";
-	case RIGHT_POINTING_DOUBLE_ANGLE_QUOTATION_MARK:
-	  return (const char *)"&raquo;";
-	case VULGAR_FRACTION_ONE_QUARTER:
-	  return (const char *)"&frac14;";
-	case VULGAR_FRACTION_ONE_HALF:
-	  return (const char *)"&frac12;";
-	case VULGAR_FRACTION_THREE_QUARTERS:
-	  return (const char *)"&frac34;";
-	case INVERTED_QUESTION_MARK:
-	  return (const char *)"&iquest;";	  
-	case LATIN_CAPITAL_LETTER_A_WITH_GRAVE:
-	  return (const char *)"&Agrave;";
-	case LATIN_CAPITAL_LETTER_A_WITH_ACUTE:
-	  return (const char *)"&Aacute;";
-	case LATIN_CAPITAL_LETTER_A_WITH_BREVE:
-	  return (const char *)"&Abreve;";
-	case LATIN_CAPITAL_LETTER_A_WITH_CIRCUMFLEX:
-	  return (const char *)"&Acirc;";
-	case LATIN_CAPITAL_LETTER_A_WITH_TILDE:
-	  return (const char *)"&Atilde;";
-	case LATIN_CAPITAL_LETTER_A_WITH_DIAERESIS:
-	  return (const char *)"&Auml;";
-	case LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE:
-	  return (const char *)"&Aring;";
-	case LATIN_CAPITAL_LETTER_AE:
-	  return (const char *)"&AElig;";
-	case LATIN_CAPITAL_LETTER_C_WITH_CARON:
-	  return (const char *)"&Ccaron;";
-	case LATIN_CAPITAL_LETTER_C_WITH_CEDILLA:
-	  return (const char *)"&Ccedil;";
-	case LATIN_CAPITAL_LETTER_E_WITH_GRAVE:
-	  return (const char *)"&Egrave;";
-	case LATIN_CAPITAL_LETTER_E_WITH_ACUTE:
-	  return (const char *)"&Eacute;";
-	case LATIN_CAPITAL_LETTER_E_WITH_CARON:
-	  return (const char *)"&Ecaron;";
-	case LATIN_CAPITAL_LETTER_E_WITH_CIRCUMFLEX:
-	  return (const char *)"&Ecirc;";
-	case LATIN_CAPITAL_LETTER_E_WITH_DIAERESIS:
-	  return (const char *)"&Euml;";
-	case LATIN_CAPITAL_LETTER_I_WITH_GRAVE:
-	  return (const char *)"&Igrave;";
-	case LATIN_CAPITAL_LETTER_I_WITH_ACUTE:
-	  return (const char *)"&Iacute;";
-	case LATIN_CAPITAL_LETTER_I_WITH_CIRCUMFLEX:
-	  return (const char *)"&Icirc;";
-	case LATIN_CAPITAL_LETTER_I_WITH_DIAERESIS:
-	  return (const char *)"&Iuml;";
-	case LATIN_CAPITAL_LETTER_ETH:
-	  return (const char *)"&ETH;";
-	case LATIN_CAPITAL_LETTER_N_WITH_TILDE:
-	  return (const char *)"&Ntilde;";
-	case LATIN_CAPITAL_LETTER_O_WITH_GRAVE:
-	  return (const char *)"&Ograve;";
-	case LATIN_CAPITAL_LETTER_O_WITH_ACUTE:
-	  return (const char *)"&Oacute;";
-	case LATIN_CAPITAL_LETTER_O_WITH_CIRCUMFLEX:
-	  return (const char *)"&Ocirc;";
-	case LATIN_CAPITAL_LETTER_O_WITH_TILDE:
-	  return (const char *)"&Otilde;";
-	case LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS:
-	  return (const char *)"&Ouml;";
-	case MULTIPLICATION_SIGN:
-	  return (const char *)"&times";
-	case LATIN_CAPITAL_LETTER_O_WITH_STROKE:
-	  return (const char *)"&Oslash;";
-	case LATIN_CAPITAL_LETTER_S_WITH_CARON:
-	  return (const char *)"&Scaron;";
-	case LATIN_CAPITAL_LETTER_U_WITH_GRAVE:
-	  return (const char *)"&Ugrave;";
-	case LATIN_CAPITAL_LETTER_U_WITH_ACUTE:
-	  return (const char *)"&Uacute;";
-	case LATIN_CAPITAL_LETTER_U_WITH_CIRCUMFLEX:
-	  return (const char *)"&Ucirc;";
-	case LATIN_CAPITAL_LETTER_U_WITH_DIAERESIS:
-	  return (const char *)"&Uuml;";
-	case LATIN_CAPITAL_LETTER_Y_WITH_ACUTE:
-	  return (const char *)"&Yacute;";
-	case LATIN_CAPITAL_LETTER_Z_WITH_CARON:
-	  return (const char *)"&Zcaron;";
-	case LATIN_CAPITAL_LETTER_THORN:
-	  return (const char *)"&THORN;";
-	case LATIN_SMALL_LETTER_SHARP_S:
-	  return (const char *)"&szlig;";
-	case LATIN_SMALL_LETTER_A_WITH_GRAVE:
-	  return (const char *)"&agrave;";
-	case LATIN_SMALL_LETTER_A_WITH_ACUTE:
-	  return (const char *)"&aacute;";
-	case LATIN_SMALL_LETTER_A_WITH_BREVE:
-	  return (const char *)"&abreve;";
-	case LATIN_SMALL_LETTER_A_WITH_CARON:
-	  return (const char *)"&acaron;";
-	case LATIN_SMALL_LETTER_A_WITH_CIRCUMFLEX:
-	  return (const char *)"&acirc;";
-	case LATIN_SMALL_LETTER_A_WITH_TILDE:
-	  return (const char *)"&atilde;";
-	case LATIN_SMALL_LETTER_A_WITH_DIAERESIS:
-	  return (const char *)"&auml;";
-	case LATIN_SMALL_LETTER_A_WITH_RING_ABOVE:
-	  return (const char *)"&aring;";
-	case LATIN_SMALL_LETTER_AE:
-	  return (const char *)"&aelig;";
-	case LATIN_SMALL_LETTER_C_WITH_CARON:
-	  return (const char *)"&ccaron;";
-	case LATIN_SMALL_LETTER_C_WITH_CEDILLA:
-	  return (const char *)"&ccedil;";
-	case LATIN_SMALL_LETTER_E_WITH_GRAVE:
-	  return (const char *)"&egrave;";
-	case LATIN_SMALL_LETTER_E_WITH_ACUTE:
-	  return (const char *)"&eacute;";
-	case LATIN_SMALL_LETTER_E_WITH_CARON:
-	  return (const char *)"&ecaron;";
-	case LATIN_SMALL_LETTER_E_WITH_CIRCUMFLEX:
-	  return (const char *)"&ecirc;";
-	case LATIN_SMALL_LETTER_E_WITH_DIAERESIS:
-	  return (const char *)"&euml;";
-	case LATIN_SMALL_LETTER_I_WITH_GRAVE:
-	  return (const char *)"&igrave;";
-	case LATIN_SMALL_LETTER_I_WITH_ACUTE:
-	  return (const char *)"&iacute;";
-	case LATIN_SMALL_LETTER_I_WITH_CIRCUMFLEX:
-	  return (const char *)"&icirc;";
-	case LATIN_SMALL_LETTER_I_WITH_DIAERESIS:
-	  return (const char *)"&iuml;";
-	case LATIN_SMALL_LETTER_ETH:
-	  return (const char *)"&eth;";
-	case LATIN_SMALL_LETTER_N_WITH_TILDE:
-	  return (const char *)"&ntilde;";
-	case LATIN_SMALL_LETTER_O_WITH_GRAVE:
-	  return (const char *)"&ograve;";
-	case LATIN_SMALL_LETTER_O_WITH_ACUTE:
-	  return (const char *)"&oacute;";
-	case LATIN_SMALL_LETTER_O_WITH_CIRCUMFLEX:
-	  return (const char *)"&ocirc;";
-	case LATIN_SMALL_LETTER_O_WITH_TILDE:
-	  return (const char *)"&otilde;";
-	case LATIN_SMALL_LETTER_O_WITH_DIAERESIS:
-	  return (const char *)"&ouml;";
-	case DIVISION_SIGN:
-	  return (const char *)"&divide;";
-	case LATIN_SMALL_LETTER_O_WITH_STROKE:
-	  return (const char *)"&oslash;";
-	case LATIN_SMALL_LETTER_S_WITH_CARON:
-	  return (const char *)"&scaron;";
-	case LATIN_SMALL_LETTER_U_WITH_GRAVE:
-	  return (const char *)"&ugrave;";
-	case LATIN_SMALL_LETTER_U_WITH_ACUTE:
-	  return (const char *)"&uacute;";
-	case LATIN_SMALL_LETTER_U_WITH_CIRCUMFLEX:
-	  return (const char *)"&ucirc;";
-	case LATIN_SMALL_LETTER_U_WITH_DIAERESIS:
-	  return (const char *)"&uuml;";
-	case LATIN_SMALL_LETTER_Y_WITH_ACUTE:
-	  return (const char *)"&yacute;";
-	case LATIN_SMALL_LETTER_THORN:
-	  return (const char *)"&thorn;";
-	case LATIN_SMALL_LETTER_Y_WITH_DIAERESIS:
-	  return (const char *)"&yuml;";
-	case LATIN_SMALL_LETTER_Z_WITH_CARON:
-	  return (const char *)"&zcaron;";
-	case EURO_CURRENCY_SIGN:
-	  return (const char *)"&euro;";
-	case 0:
-	  return (const char *)"";
-	default:
-	  sprintf(buf,"&#%u;",(unsigned)c);
-	  return buf;  /* undefined */
-      }
-      /* break; unreachable code */
-    case XML:   /* only 5 &xxx;-ENTITIES ar defined by default */
-      if ( c >= SPACE && c <= TILDE ) { /* ASCII */
-        switch (c) {
-          case '&':
-            return (const char *)"&amp;";
-          case '\'':
-            return (const char *)"&apos;";
-          case '"':
-            return (const char *)"&quot;";
-          case '<':
-            return (const char *)"&lt;";
-          case '>':
-            return (const char *)"&gt;";
-        }
-        buf[0] = (char)c;
-        return buf;
-      }
-      switch (c) {    /* subject of change! */
-	case PICTURE:
-	  return (const char *)"(PICTURE)";
-        case UNKNOWN:
-          return (const char *)"_"; /* better use colored symbol? */
-        case LINE_FEED:             /* \n handled somwhere else? */
-	case FORM_FEED:
-	case CARRIAGE_RETURN:
-	  return (const char *)"<br />";
-	case NO_BREAK_SPACE:
-	  return (const char *)"<nobr />";
-	case 0:
-	  return (const char *)"";
-	default:
-	  sprintf(buf,"&#x%03x;",(unsigned)c);
-	  return buf;  /* undefined */
-      }
-      /* break; unreachable code */
-    case SGML:
-      switch (c) {
-	default:
-	  sprintf(buf,"&#%u;",(unsigned)c);
-	  return buf;  /* UNDEFINED */
-      }
-      /* break; unreachable code */
-    case ASCII: /* mainly used for debugging */
-      if ( c=='\n' || (c>= 0x20 && c <= 0x7F) ) {
-        buf[0] = (char)c;
-        return buf;
-      }
-      switch (c) {
-	/* extra */
-	case UNKNOWN:
-	  return (const char *)"(?)";
-	case PICTURE:
-	  return (const char *)"(?)";
-		
-	default:
-	  /* snprintf seems to be no standard, so I use insecure sprintf */
-	  if ((unsigned)c>255) sprintf(buf,"(0x%04x)",(unsigned)c);
-	  else                 sprintf(buf,"(0x%02x)",(unsigned)c);
-	  return buf;  /* UNDEFINED; */
-      }
-      /* break; unreachable code */
-    default: /* use UTF8 as default, test with xterm -u8 */
-      /* extra */
-      if ( c == UNKNOWN )  return (const char *)"_";
-      if ( c == PICTURE )  return (const char *)"_"; /* Due to Mobile OCR */
-      if ( c <= (wchar_t)0x0000007F ) {  /* UTF8 == 7bit ASCII */
-        buf[0] = (char)c;
-        return buf;
-      }
-      if ( c <= (wchar_t)0x000007FF ) {  /* UTF8 == 11bit */
-        buf[0] = (char)(0xc0|((c>> 6) & 0x1f)); /* 110xxxxx */
-        buf[1] = (char)(0x80|( c      & 0x3f)); /* 10xxxxxx */
-        buf[2] = (char)0; /* terminate string */
-        return buf;
-      }
-      /* wchar_t is 16bit for Borland-C !? Jan07 */
-      if ( c <= (wchar_t)0x0000FFFF ) {  /* UTF8 == 16bit */
-        buf[0] = (char)(0xe0|((c>>12) & 0x0f)); /* 1110xxxx */
-        buf[1] = (char)(0x80|((c>> 6) & 0x3f)); /* 10xxxxxx */
-        buf[2] = (char)(0x80|( c      & 0x3f)); /* 10xxxxxx */
-        buf[3] = (char)0; /* terminate string */
-        return buf;
-      }
-      if ( c <= (wchar_t)0x001FFFFF ) {  /* UTF8 == 21bit */
-        buf[0] = (char)(0xf0|((c>>18) & 0x07)); /* 11110xxx */
-        buf[1] = (char)(0x80|((c>>12) & 0x3f)); /* 10xxxxxx */
-        buf[2] = (char)(0x80|((c>> 6) & 0x3f)); /* 10xxxxxx */
-        buf[3] = (char)(0x80|( c      & 0x3f)); /* 10xxxxxx */
-        buf[4] = (char)0; /* terminate string */
-        return buf;
-      }
-      if ( c <= (wchar_t)0x03FFFFFF ) {  /* UTF8 == 26bit */
-        buf[0] = (char)(0xf8|((c>>24) & 0x03)); /* 111110xx */
-        buf[1] = (char)(0x80|((c>>18) & 0x3f)); /* 10xxxxxx */
-        buf[2] = (char)(0x80|((c>>12) & 0x3f)); /* 10xxxxxx */
-        buf[3] = (char)(0x80|((c>> 6) & 0x3f)); /* 10xxxxxx */
-        buf[4] = (char)(0x80|( c      & 0x3f)); /* 10xxxxxx */
-        buf[5] = (char)0; /* terminate string */
-        return buf;
-      }
-      if ( c <= (wchar_t)0x7FFFFFFF ) {  /* UTF8 == 31bit */
-        buf[0] = (char)(0xfc|((c>>30) & 0x01)); /* 1111110x */
-        buf[1] = (char)(0x80|((c>>24) & 0x3f)); /* 10xxxxxx */
-        buf[2] = (char)(0x80|((c>>18) & 0x3f)); /* 10xxxxxx */
-        buf[3] = (char)(0x80|((c>>12) & 0x3f)); /* 10xxxxxx */
-        buf[4] = (char)(0x80|((c>> 6) & 0x3f)); /* 10xxxxxx */
-        buf[5] = (char)(0x80|( c      & 0x3f)); /* 10xxxxxx */
-        buf[6] = (char)0; /* terminate string */
-        return buf;
-      }
-      return (const char *)UNDEFINED;
-  }
-}