entangledstate-isbn 1.4.0 → 1.4.1

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

@@ -0,0 +1,87 @@
+/*
+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

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

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

@@ -0,0 +1,1314 @@
+/*
+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;
+  }
+}