dos -> unix

21 files changed, 6268 insertions, 6268 deletions

diff --git a/libX11/modules/Makefile.am b/libX11/modules/Makefile.am
index 1ef0dfbd7..76e33839c 100644
--- a/libX11/modules/Makefile.am
+++ b/libX11/modules/Makefile.am
@@ -1 +1 @@
-SUBDIRS=im lc om

+SUBDIRS=im lc om
diff --git a/libX11/modules/im/Makefile.am b/libX11/modules/im/Makefile.am
index 330a6dd6d..0974cf615 100644
--- a/libX11/modules/im/Makefile.am
+++ b/libX11/modules/im/Makefile.am
@@ -1 +1 @@
-SUBDIRS=ximcp

+SUBDIRS=ximcp
diff --git a/libX11/modules/im/ximcp/Makefile.am b/libX11/modules/im/ximcp/Makefile.am
index 319b3089e..16a6ca878 100644
--- a/libX11/modules/im/ximcp/Makefile.am
+++ b/libX11/modules/im/ximcp/Makefile.am
@@ -1,59 +1,59 @@
-AM_CPPFLAGS= \

-	-I$(top_srcdir)/include \

-	-I$(top_srcdir)/include/X11 \

-	-I$(top_builddir)/include \

-	-I$(top_builddir)/include/X11 \

-	-I$(top_srcdir)/src/xcms \

-	-I$(top_srcdir)/src/xkb \

-	-I$(top_srcdir)/src/xlibi18n \

-	-D_BSD_SOURCE -DXIM_t -DTRANS_CLIENT

-

-AM_CFLAGS= \

-	$(X11_CFLAGS) \

-	$(BIGFONT_CFLAGS) \

-	$(MALLOC_ZERO_CFLAGS) \

-	$(CWARNFLAGS)

-

-if XLIB_LOADABLE_I18N

-

-commonlibdir = $(X11_LOCALELIBDIR)/common

-commonlib_LTLIBRARIES=ximcp.la

-ximcp_la_LDFLAGS = -module -version-number 2:0:0

-ximcp_la_LIBADD = $(I18N_MODULE_LIBS)

-

-else

-

-noinst_LTLIBRARIES=libximcp.la

-

-endif

-

-

-ximcp_la_SOURCES = \

-	imCallbk.c \

-	imDefFlt.c \

-	imDefIc.c \

-	imDefIm.c \

-	imDefLkup.c \

-	imDispch.c \

-	imEvToWire.c \

-	imExten.c \

-	imImSw.c \

-	imInsClbk.c \

-	imInt.c \

-	imLcFlt.c \

-	imLcGIc.c \

-	imLcIc.c \

-	imLcIm.c \

-	imLcLkup.c \

-	imLcPrs.c \

-	imLcSIc.c \

-	imRmAttr.c \

-	imRm.c \

-	imThaiFlt.c \

-	imThaiIc.c \

-	imThaiIm.c \

-	imTrans.c \

-	imTransR.c \

-	imTrX.c

-

-libximcp_la_SOURCES = $(ximcp_la_SOURCES)

+AM_CPPFLAGS= \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/include/X11 \
+	-I$(top_builddir)/include \
+	-I$(top_builddir)/include/X11 \
+	-I$(top_srcdir)/src/xcms \
+	-I$(top_srcdir)/src/xkb \
+	-I$(top_srcdir)/src/xlibi18n \
+	-D_BSD_SOURCE -DXIM_t -DTRANS_CLIENT
+
+AM_CFLAGS= \
+	$(X11_CFLAGS) \
+	$(BIGFONT_CFLAGS) \
+	$(MALLOC_ZERO_CFLAGS) \
+	$(CWARNFLAGS)
+
+if XLIB_LOADABLE_I18N
+
+commonlibdir = $(X11_LOCALELIBDIR)/common
+commonlib_LTLIBRARIES=ximcp.la
+ximcp_la_LDFLAGS = -module -version-number 2:0:0
+ximcp_la_LIBADD = $(I18N_MODULE_LIBS)
+
+else
+
+noinst_LTLIBRARIES=libximcp.la
+
+endif
+
+
+ximcp_la_SOURCES = \
+	imCallbk.c \
+	imDefFlt.c \
+	imDefIc.c \
+	imDefIm.c \
+	imDefLkup.c \
+	imDispch.c \
+	imEvToWire.c \
+	imExten.c \
+	imImSw.c \
+	imInsClbk.c \
+	imInt.c \
+	imLcFlt.c \
+	imLcGIc.c \
+	imLcIc.c \
+	imLcIm.c \
+	imLcLkup.c \
+	imLcPrs.c \
+	imLcSIc.c \
+	imRmAttr.c \
+	imRm.c \
+	imThaiFlt.c \
+	imThaiIc.c \
+	imThaiIm.c \
+	imTrans.c \
+	imTransR.c \
+	imTrX.c
+
+libximcp_la_SOURCES = $(ximcp_la_SOURCES)
diff --git a/libX11/modules/im/ximcp/imEvToWire.c b/libX11/modules/im/ximcp/imEvToWire.c
index 8dd263381..497c86598 100644
--- a/libX11/modules/im/ximcp/imEvToWire.c
+++ b/libX11/modules/im/ximcp/imEvToWire.c
@@ -1,788 +1,788 @@
-/***********************************************************

-Copyright 1993 by Digital Equipment Corporation, Maynard, Massachusetts,

-

-                        All Rights Reserved

-

-Permission to use, copy, modify, and distribute this software and its

-documentation for any purpose and without fee is hereby granted,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation, and that the name of Digital not be

-used in advertising or publicity pertaining to distribution of the

-software without specific, written prior permission.

-

-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

-SOFTWARE.

-

-******************************************************************/

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include <X11/Xlibint.h>

-#include <X11/Xlib.h>

-#include "Ximint.h"

-

-

-#define sw16(n, s) ((s) ?                    \

-		      (((n) << 8 & 0xff00) | \

-		       ((n) >> 8 & 0xff)     \

-		      ) : n)

-

-#define sw32(n, s) ((s) ?                         \

-		      (((n) << 24 & 0xff000000) | \

-		       ((n) <<  8 & 0xff0000) |   \

-		       ((n) >>  8 & 0xff00) |     \

-		       ((n) >> 24 & 0xff)         \

-		      ) : n)

-

-Status

-_XimProtoEventToWire(

-    register XEvent *re,	/* pointer to where event should be reformatted */

-    register xEvent *event,	/* wire protocol event */

-    Bool sw)         /* swap byte? */

-{

-	switch (event->u.u.type = re->type) {

-	      case KeyPress:

-	      case KeyRelease:

-	        {

-			register XKeyEvent *ev = (XKeyEvent*) re;

-			event->u.keyButtonPointer.root	= sw32(ev->root, sw);

-			event->u.keyButtonPointer.event	 =

-			    sw32(ev->window, sw);

-			event->u.keyButtonPointer.child  =

-			    sw32(ev->subwindow, sw);

-			event->u.keyButtonPointer.time	 = sw32(ev->time, sw);

-			event->u.keyButtonPointer.eventX = sw16(ev->x, sw) ;

-			event->u.keyButtonPointer.eventY = sw16(ev->y, sw) ;

-			event->u.keyButtonPointer.rootX	 =

-			    sw16(ev->x_root, sw);

-			event->u.keyButtonPointer.rootY  =

-			    sw16(ev->y_root, sw);

-			event->u.keyButtonPointer.state  = sw16(ev->state, sw);

-			event->u.keyButtonPointer.sameScreen = ev->same_screen;

-			event->u.u.detail = ev->keycode;

-		}

-	      	break;

-	      case ButtonPress:

-	      case ButtonRelease:

-	        {

-			register XButtonEvent *ev =  (XButtonEvent *) re;

-			event->u.keyButtonPointer.root	 = sw32(ev->root, sw);

-			event->u.keyButtonPointer.event	 = sw32(ev->window, sw);

-			event->u.keyButtonPointer.child	 = sw32(ev->subwindow, sw);

-			event->u.keyButtonPointer.time	 = sw32(ev->time, sw);

-			event->u.keyButtonPointer.eventX = sw16(ev->x, sw);

-			event->u.keyButtonPointer.eventY = sw16(ev->y, sw);

-			event->u.keyButtonPointer.rootX	 = sw16(ev->x_root, sw);

-			event->u.keyButtonPointer.rootY	 = sw16(ev->y_root, sw);

-			event->u.keyButtonPointer.state	 = sw16(ev->state, sw);

-			event->u.keyButtonPointer.sameScreen	= ev->same_screen;

-			event->u.u.detail		= ev->button;

-		}

-	        break;

-	      case MotionNotify:

-	        {

-			register XMotionEvent *ev =   (XMotionEvent *)re;

-			event->u.keyButtonPointer.root	= sw32(ev->root, sw);

-			event->u.keyButtonPointer.event	= sw32(ev->window, sw);

-			event->u.keyButtonPointer.child	= sw32(ev->subwindow, sw);

-			event->u.keyButtonPointer.time	= sw32(ev->time, sw);

-			event->u.keyButtonPointer.eventX= sw16(ev->x, sw);

-			event->u.keyButtonPointer.eventY= sw16(ev->y, sw);

-			event->u.keyButtonPointer.rootX	= sw16(ev->x_root, sw);

-			event->u.keyButtonPointer.rootY	= sw16(ev->y_root, sw);

-			event->u.keyButtonPointer.state	= sw16(ev->state, sw);

-			event->u.keyButtonPointer.sameScreen= ev->same_screen;

-			event->u.u.detail		= ev->is_hint;

-		}

-	        break;

-	      case EnterNotify:

-	      case LeaveNotify:

-		{

-			register XCrossingEvent *ev   = (XCrossingEvent *) re;

-			event->u.enterLeave.root	= sw32(ev->root, sw);

-			event->u.enterLeave.event	= sw32(ev->window, sw);

-			event->u.enterLeave.child	= sw32(ev->subwindow, sw);

-			event->u.enterLeave.time	= sw32(ev->time, sw);

-			event->u.enterLeave.eventX	= sw16(ev->x, sw);

-			event->u.enterLeave.eventY	= sw16(ev->y, sw);

-			event->u.enterLeave.rootX	= sw16(ev->x_root, sw);

-			event->u.enterLeave.rootY	= sw16(ev->y_root, sw);

-			event->u.enterLeave.state	= sw16(ev->state, sw);

-			event->u.enterLeave.mode	= ev->mode;

-			event->u.enterLeave.flags	= 0;

-			if (ev->same_screen) {

-				event->u.enterLeave.flags |= ELFlagSameScreen;

-				}

-			if (ev->focus) {

-				event->u.enterLeave.flags |= ELFlagFocus;

-				}

-			event->u.u.detail		= ev->detail;

-		}

-		  break;

-	      case FocusIn:

-	      case FocusOut:

-		{

-			register XFocusChangeEvent *ev = (XFocusChangeEvent *) re;

-			event->u.focus.window	= sw32(ev->window, sw);

-			event->u.focus.mode	= ev->mode;

-			event->u.u.detail	= ev->detail;

-		}

-		  break;

-	      case KeymapNotify:

-		{

-			register XKeymapEvent *ev = (XKeymapEvent *) re;

-			memcpy((char *)(((xKeymapEvent *) event)->map),

-			       &ev->key_vector[1],

-			       sizeof (((xKeymapEvent *) event)->map));

-		}

-		break;

-	      case Expose:

-		{

-			register XExposeEvent *ev = (XExposeEvent *) re;

-			event->u.expose.window		= sw32(ev->window, sw);

-			event->u.expose.x		= sw16(ev->x, sw);

-			event->u.expose.y		= sw16(ev->y, sw);

-			event->u.expose.width		= sw16(ev->width, sw);

-			event->u.expose.height		= sw16(ev->height, sw);

-			event->u.expose.count		= sw16(ev->count, sw);

-		}

-		break;

-	      case GraphicsExpose:

-		{

-		    register XGraphicsExposeEvent *ev =

-			(XGraphicsExposeEvent *) re;

-		    event->u.graphicsExposure.drawable	= sw32(ev->drawable, sw);

-		    event->u.graphicsExposure.x		= sw16(ev->x, sw);

-		    event->u.graphicsExposure.y		= sw16(ev->y, sw);

-		    event->u.graphicsExposure.width	= sw16(ev->width, sw);

-		    event->u.graphicsExposure.height	= sw16(ev->height, sw);

-		    event->u.graphicsExposure.count	= sw16(ev->count, sw);

-		    event->u.graphicsExposure.majorEvent= ev->major_code;

-		    event->u.graphicsExposure.minorEvent= sw16(ev->minor_code, sw);

-		}

-		break;

-	      case NoExpose:

-		{

-		    register XNoExposeEvent *ev = (XNoExposeEvent *) re;

-		    event->u.noExposure.drawable	= sw32(ev->drawable, sw);

-		    event->u.noExposure.majorEvent	= ev->major_code;

-		    event->u.noExposure.minorEvent	= sw16(ev->minor_code, sw);

-		}

-		break;

-	      case VisibilityNotify:

-		{

-		    register XVisibilityEvent *ev = (XVisibilityEvent *) re;

-		    event->u.visibility.window		= sw32(ev->window, sw);

-		    event->u.visibility.state		= ev->state;

-		}

-		break;

-	      case CreateNotify:

-		{

-		    register XCreateWindowEvent *ev =

-			 (XCreateWindowEvent *) re;

-		    event->u.createNotify.window	= sw32(ev->window, sw);

-		    event->u.createNotify.parent	= sw32(ev->parent, sw);

-		    event->u.createNotify.x		= sw16(ev->x, sw);

-		    event->u.createNotify.y		= sw16(ev->y, sw);

-		    event->u.createNotify.width		= sw16(ev->width, sw);

-		    event->u.createNotify.height	= sw16(ev->height, sw);

-		    event->u.createNotify.borderWidth	= sw16(ev->border_width, sw);

-		    event->u.createNotify.override	= ev->override_redirect;

-		}

-		break;

-	      case DestroyNotify:

-		{

-		    register XDestroyWindowEvent *ev =

-				(XDestroyWindowEvent *) re;

-		    event->u.destroyNotify.window	= sw32(ev->window, sw);

-		    event->u.destroyNotify.event	= sw32(ev->event, sw);

-		}

-		break;

-	      case UnmapNotify:

-		{

-		    register XUnmapEvent *ev = (XUnmapEvent *) re;

-		    event->u.unmapNotify.window	= sw32(ev->window, sw);

-		    event->u.unmapNotify.event	= sw32(ev->event, sw);

-		    event->u.unmapNotify.fromConfigure	= ev->from_configure;

-		}

-		break;

-	      case MapNotify:

-		{

-		    register XMapEvent *ev = (XMapEvent *) re;

-		    event->u.mapNotify.window	= sw32(ev->window, sw);

-		    event->u.mapNotify.event	= sw32(ev->event, sw);

-		    event->u.mapNotify.override	= ev->override_redirect;

-		}

-		break;

-	      case MapRequest:

-		{

-		    register XMapRequestEvent *ev = (XMapRequestEvent *) re;

-		    event->u.mapRequest.window	= sw32(ev->window, sw);

-		    event->u.mapRequest.parent	= sw32(ev->parent, sw);

-		}

-		break;

-	      case ReparentNotify:

-		{

-		    register XReparentEvent *ev = (XReparentEvent *) re;

-		    event->u.reparent.window	= sw32(ev->window, sw);

-		    event->u.reparent.event	= sw32(ev->event, sw);

-		    event->u.reparent.parent	= sw32(ev->parent, sw);

-		    event->u.reparent.x		= sw16(ev->x, sw);

-		    event->u.reparent.y		= sw16(ev->y, sw);

-		    event->u.reparent.override	= ev->override_redirect;

-		}

-		break;

-	      case ConfigureNotify:

-		{

-		    register XConfigureEvent *ev = (XConfigureEvent *) re;

-		    event->u.configureNotify.window	= sw32(ev->window, sw);

-		    event->u.configureNotify.event	= sw32(ev->event, sw);

-		    event->u.configureNotify.aboveSibling	= sw32(ev->above, sw);

-		    event->u.configureNotify.x		= sw16(ev->x, sw);

-		    event->u.configureNotify.y		= sw16(ev->y, sw);

-		    event->u.configureNotify.width	= sw16(ev->width, sw);

-		    event->u.configureNotify.height	= sw16(ev->height, sw);

-		    event->u.configureNotify.borderWidth= sw16(ev->border_width, sw);

-		    event->u.configureNotify.override	= ev->override_redirect;

-		}

-		break;

-	      case ConfigureRequest:

-		{

-		    register XConfigureRequestEvent *ev =

-		        (XConfigureRequestEvent *) re;

-		    event->u.configureRequest.window	= sw32(ev->window, sw);

-		    event->u.configureRequest.parent	= sw32(ev->parent, sw);

-		    event->u.configureRequest.sibling   = sw32(ev->above, sw);

-		    event->u.configureRequest.x		= sw16(ev->x, sw);

-		    event->u.configureRequest.y		= sw16(ev->y, sw);

-		    event->u.configureRequest.width	= sw16(ev->width, sw);

-		    event->u.configureRequest.height	= sw16(ev->height, sw);

-		    event->u.configureRequest.borderWidth= sw16(ev->border_width, sw);

-		    event->u.configureRequest.valueMask= sw16(ev->value_mask, sw);

-		    event->u.u.detail 			= ev->detail;

-		}

-		break;

-	      case GravityNotify:

-		{

-		    register XGravityEvent *ev  = (XGravityEvent *) re;

-		    event->u.gravity.window	= sw32(ev->window, sw);

-		    event->u.gravity.event	= sw32(ev->event, sw);

-		    event->u.gravity.x		= sw16(ev->x, sw);

-		    event->u.gravity.y		= sw16(ev->y, sw);

-		}

-		break;

-	      case ResizeRequest:

-		{

-		    register XResizeRequestEvent *ev =

-			(XResizeRequestEvent *) re;

-		    event->u.resizeRequest.window	= sw32(ev->window, sw);

-		    event->u.resizeRequest.width	= sw16(ev->width, sw);

-		    event->u.resizeRequest.height	= sw16(ev->height, sw);

-		}

-		break;

-	      case CirculateNotify:

-		{

-		    register XCirculateEvent *ev = (XCirculateEvent *) re;

-		    event->u.circulate.window		= sw32(ev->window, sw);

-		    event->u.circulate.event		= sw32(ev->event, sw);

-		    event->u.circulate.place		= ev->place;

-		}

-		break;

-	      case CirculateRequest:

-		{

-		    register XCirculateRequestEvent *ev =

-		        (XCirculateRequestEvent *) re;

-		    event->u.circulate.window		= sw32(ev->window, sw);

-		    event->u.circulate.event		= sw32(ev->parent, sw);

-		    event->u.circulate.place		= ev->place;

-		}

-		break;

-	      case PropertyNotify:

-		{

-		    register XPropertyEvent *ev = (XPropertyEvent *) re;

-		    event->u.property.window		= sw32(ev->window, sw);

-		    event->u.property.atom		= sw32(ev->atom, sw);

-		    event->u.property.time		= sw32(ev->time, sw);

-		    event->u.property.state		= ev->state;

-		}

-		break;

-	      case SelectionClear:

-		{

-		    register XSelectionClearEvent *ev =

-			 (XSelectionClearEvent *) re;

-		    event->u.selectionClear.window	= sw32(ev->window, sw);

-		    event->u.selectionClear.atom	= sw32(ev->selection, sw);

-		    event->u.selectionClear.time	= sw32(ev->time, sw);

-		}

-		break;

-	      case SelectionRequest:

-		{

-		    register XSelectionRequestEvent *ev =

-		        (XSelectionRequestEvent *) re;

-		    event->u.selectionRequest.owner	= sw32(ev->owner, sw);

-		    event->u.selectionRequest.requestor	= sw32(ev->requestor, sw);

-		    event->u.selectionRequest.selection	= sw32(ev->selection, sw);

-		    event->u.selectionRequest.target	= sw32(ev->target, sw);

-		    event->u.selectionRequest.property	= sw32(ev->property, sw);

-		    event->u.selectionRequest.time	= sw32(ev->time, sw);

-		}

-		break;

-	      case SelectionNotify:

-		{

-		    register XSelectionEvent *ev = (XSelectionEvent *) re;

-		    event->u.selectionNotify.requestor	= sw32(ev->requestor, sw);

-		    event->u.selectionNotify.selection	= sw32(ev->selection, sw);

-		    event->u.selectionNotify.target	= sw32(ev->target, sw);

-		    event->u.selectionNotify.property	= sw32(ev->property, sw);

-		    event->u.selectionNotify.time	= sw32(ev->time, sw);

-		}

-		break;

-	      case ColormapNotify:

-		{

-		    register XColormapEvent *ev = (XColormapEvent *) re;

-		    event->u.colormap.window		= sw32(ev->window, sw);

-		    event->u.colormap.colormap		= sw32(ev->colormap, sw);

-		    event->u.colormap.new		= ev->new;

-		    event->u.colormap.state		= ev->state;

-	        }

-		break;

-	      case ClientMessage:

-		{

-		   register int i;

-		   register XClientMessageEvent *ev

-		   			= (XClientMessageEvent *) re;

-		   event->u.clientMessage.window = sw32(ev->window, sw);

-		   event->u.u.detail		 = ev->format;

-		   switch (ev->format) {

-			case 8:

-			  event->u.clientMessage.u.b.type   = sw32(ev->message_type, sw);

-			  for (i = 0; i < 20; i++)

-			   event->u.clientMessage.u.b.bytes[i] = ev->data.b[i];

-			  break;

-			case 16:

-			  event->u.clientMessage.u.s.type   = sw32(ev->message_type, sw);

-			  event->u.clientMessage.u.s.shorts0   = sw16(ev->data.s[0], sw);

-			  event->u.clientMessage.u.s.shorts1   = sw16(ev->data.s[1], sw);

-			  event->u.clientMessage.u.s.shorts2   = sw16(ev->data.s[2], sw);

-			  event->u.clientMessage.u.s.shorts3   = sw16(ev->data.s[3], sw);

-			  event->u.clientMessage.u.s.shorts4   = sw16(ev->data.s[4], sw);

-			  event->u.clientMessage.u.s.shorts5   = sw16(ev->data.s[5], sw);

-			  event->u.clientMessage.u.s.shorts6   = sw16(ev->data.s[6], sw);

-			  event->u.clientMessage.u.s.shorts7   = sw16(ev->data.s[7], sw);

-			  event->u.clientMessage.u.s.shorts8   = sw16(ev->data.s[8], sw);

-			  event->u.clientMessage.u.s.shorts9   = sw16(ev->data.s[9], sw);

-			  break;

-			case 32:

-			  event->u.clientMessage.u.l.type   = sw32(ev->message_type, sw);

-			  event->u.clientMessage.u.l.longs0   = sw32(ev->data.l[0], sw);

-			  event->u.clientMessage.u.l.longs1   = sw32(ev->data.l[1], sw);

-			  event->u.clientMessage.u.l.longs2   = sw32(ev->data.l[2], sw);

-			  event->u.clientMessage.u.l.longs3   = sw32(ev->data.l[3], sw);

-			  event->u.clientMessage.u.l.longs4   = sw32(ev->data.l[4], sw);

-			  break;

-			default:

-			  /* client passing bogus data, let server complain */

-			  break;

-			}

-		    }

-		break;

-	      case MappingNotify:

-		  {

-		    register XMappingEvent *ev = (XMappingEvent *) re;

-		    event->u.mappingNotify.firstKeyCode = ev->first_keycode;

-		    event->u.mappingNotify.request 	= ev->request;

-		    event->u.mappingNotify.count	= ev->count;

-		   }

-		break;

-

-	      default:

-		return(0);

-	}

-	/* Common process */

-	if (((XAnyEvent *)re)->send_event)

-	    event->u.u.type |= 0x80;

-	event->u.u.sequenceNumber =

-	    ((XAnyEvent *)re)->serial & ~((unsigned long)0xffff);

-	event->u.u.sequenceNumber = sw16(event->u.u.sequenceNumber, sw);

-	return(1);

-}

-

-

-/*

- * reformat a wire event into an XEvent structure of the right type.

- */

-Bool

-_XimProtoWireToEvent(

-    register XEvent *re,	/* pointer to where event should be reformatted */

-    register xEvent *event,	/* wire protocol event */

-    Bool sw)                /* swap byte? */

-{

-

-	re->type = event->u.u.type & 0x7f;

-	((XAnyEvent *)re)->serial = sw16(event->u.u.sequenceNumber, sw);

-	((XAnyEvent *)re)->send_event = ((event->u.u.type & 0x80) != 0);

-	((XAnyEvent *)re)->display = NULL;

-

-	/* Ignore the leading bit of the event type since it is set when a

-		client sends an event rather than the server. */

-

-	switch (event-> u.u.type & 0177) {

-	      case KeyPress:

-	      case KeyRelease:

-	        {

-			register XKeyEvent *ev = (XKeyEvent*) re;

-			ev->root 	= sw32(event->u.keyButtonPointer.root, sw);

-			ev->window 	= sw32(event->u.keyButtonPointer.event, sw);

-			ev->subwindow 	= sw32(event->u.keyButtonPointer.child, sw);

-			ev->time 	= sw32(event->u.keyButtonPointer.time, sw);

-			ev->x 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventX, sw));

-			ev->y 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventY, sw));

-			ev->x_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootX, sw));

-			ev->y_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootY, sw));

-			ev->state	= sw16(event->u.keyButtonPointer.state, sw);

-			ev->same_screen	= event->u.keyButtonPointer.sameScreen;

-			ev->keycode 	= event->u.u.detail;

-		}

-	      	break;

-	      case ButtonPress:

-	      case ButtonRelease:

-	        {

-			register XButtonEvent *ev =  (XButtonEvent *) re;

-			ev->root 	= sw32(event->u.keyButtonPointer.root, sw);

-			ev->window 	= sw32(event->u.keyButtonPointer.event, sw);

-			ev->subwindow 	= sw32(event->u.keyButtonPointer.child, sw);

-			ev->time 	= sw32(event->u.keyButtonPointer.time, sw);

-			ev->x 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventX, sw));

-			ev->y 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventY, sw));

-			ev->x_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootX, sw));

-			ev->y_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootY, sw));

-			ev->state	= sw16(event->u.keyButtonPointer.state, sw);

-			ev->same_screen	= event->u.keyButtonPointer.sameScreen;

-			ev->button 	= event->u.u.detail;

-		}

-	        break;

-	      case MotionNotify:

-	        {

-			register XMotionEvent *ev =   (XMotionEvent *)re;

-			ev->root 	= sw32(event->u.keyButtonPointer.root, sw);

-			ev->window 	= sw32(event->u.keyButtonPointer.event, sw);

-			ev->subwindow 	= sw32(event->u.keyButtonPointer.child, sw);

-			ev->time 	= sw32(event->u.keyButtonPointer.time, sw);

-			ev->x 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventX, sw));

-			ev->y 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventY, sw));

-			ev->x_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootX, sw));

-			ev->y_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootY, sw));

-			ev->state	= sw16(event->u.keyButtonPointer.state, sw);

-			ev->same_screen	= event->u.keyButtonPointer.sameScreen;

-			ev->is_hint 	= event->u.u.detail;

-		}

-	        break;

-	      case EnterNotify:

-	      case LeaveNotify:

-		{

-			register XCrossingEvent *ev   = (XCrossingEvent *) re;

-			ev->root	= sw32(event->u.enterLeave.root, sw);

-			ev->window	= sw32(event->u.enterLeave.event, sw);

-			ev->subwindow	= sw32(event->u.enterLeave.child, sw);

-			ev->time	= sw32(event->u.enterLeave.time, sw);

-			ev->x		= cvtINT16toInt(sw16(event->u.enterLeave.eventX, sw));

-			ev->y		= cvtINT16toInt(sw16(event->u.enterLeave.eventY, sw));

-			ev->x_root	= cvtINT16toInt(sw16(event->u.enterLeave.rootX, sw));

-			ev->y_root	= cvtINT16toInt(sw16(event->u.enterLeave.rootY, sw));

-			ev->state	= sw16(event->u.enterLeave.state, sw);

-			ev->mode	= event->u.enterLeave.mode;

-			ev->same_screen = (event->u.enterLeave.flags &

-				ELFlagSameScreen) && True;

-			ev->focus	= (event->u.enterLeave.flags &

-			  	ELFlagFocus) && True;

-			ev->detail	= event->u.u.detail;

-		}

-		  break;

-	      case FocusIn:

-	      case FocusOut:

-		{

-			register XFocusChangeEvent *ev = (XFocusChangeEvent *) re;

-			ev->window 	= sw32(event->u.focus.window, sw);

-			ev->mode	= event->u.focus.mode;

-			ev->detail	= event->u.u.detail;

-		}

-		  break;

-	      case KeymapNotify:

-		{

-			register XKeymapEvent *ev = (XKeymapEvent *) re;

-			ev->window	= None;

-			memcpy(&ev->key_vector[1],

-			       (char *)((xKeymapEvent *) event)->map,

-			       sizeof (((xKeymapEvent *) event)->map));

-		}

-		break;

-	      case Expose:

-		{

-			register XExposeEvent *ev = (XExposeEvent *) re;

-			ev->window	= sw32(event->u.expose.window, sw);

-			ev->x		= sw16(event->u.expose.x, sw);

-			ev->y		= sw16(event->u.expose.y, sw);

-			ev->width	= sw16(event->u.expose.width, sw);

-			ev->height	= sw16(event->u.expose.height, sw);

-			ev->count	= sw16(event->u.expose.count, sw);

-		}

-		break;

-	      case GraphicsExpose:

-		{

-		    register XGraphicsExposeEvent *ev =

-			(XGraphicsExposeEvent *) re;

-		    ev->drawable	= sw32(event->u.graphicsExposure.drawable, sw);

-		    ev->x		= sw16(event->u.graphicsExposure.x, sw);

-		    ev->y		= sw16(event->u.graphicsExposure.y, sw);

-		    ev->width		= sw16(event->u.graphicsExposure.width, sw);

-		    ev->height		= sw16(event->u.graphicsExposure.height, sw);

-		    ev->count		= sw16(event->u.graphicsExposure.count, sw);

-		    ev->major_code	= event->u.graphicsExposure.majorEvent;

-		    ev->minor_code	= sw16(event->u.graphicsExposure.minorEvent, sw);

-		}

-		break;

-	      case NoExpose:

-		{

-		    register XNoExposeEvent *ev = (XNoExposeEvent *) re;

-		    ev->drawable	= sw32(event->u.noExposure.drawable, sw);

-		    ev->major_code	= event->u.noExposure.majorEvent;

-		    ev->minor_code	= sw16(event->u.noExposure.minorEvent, sw);

-		}

-		break;

-	      case VisibilityNotify:

-		{

-		    register XVisibilityEvent *ev = (XVisibilityEvent *) re;

-		    ev->window		= sw32(event->u.visibility.window, sw);

-		    ev->state		= event->u.visibility.state;

-		}

-		break;

-	      case CreateNotify:

-		{

-		    register XCreateWindowEvent *ev =

-			 (XCreateWindowEvent *) re;

-		    ev->window		= sw32(event->u.createNotify.window, sw);

-		    ev->parent		= sw32(event->u.createNotify.parent, sw);

-		    ev->x		= cvtINT16toInt(sw16(event->u.createNotify.x, sw));

-		    ev->y		= cvtINT16toInt(sw16(event->u.createNotify.y, sw));

-		    ev->width		= sw16(event->u.createNotify.width, sw);

-		    ev->height		= sw16(event->u.createNotify.height, sw);

-		    ev->border_width	= sw16(event->u.createNotify.borderWidth, sw);

-		    ev->override_redirect	= event->u.createNotify.override;

-		}

-		break;

-	      case DestroyNotify:

-		{

-		    register XDestroyWindowEvent *ev =

-				(XDestroyWindowEvent *) re;

-		    ev->window		= sw32(event->u.destroyNotify.window, sw);

-		    ev->event		= sw32(event->u.destroyNotify.event, sw);

-		}

-		break;

-	      case UnmapNotify:

-		{

-		    register XUnmapEvent *ev = (XUnmapEvent *) re;

-		    ev->window		= sw32(event->u.unmapNotify.window, sw);

-		    ev->event		= sw32(event->u.unmapNotify.event, sw);

-		    ev->from_configure	= event->u.unmapNotify.fromConfigure;

-		}

-		break;

-	      case MapNotify:

-		{

-		    register XMapEvent *ev = (XMapEvent *) re;

-		    ev->window		= sw32(event->u.mapNotify.window, sw);

-		    ev->event		= sw32(event->u.mapNotify.event, sw);

-		    ev->override_redirect	= event->u.mapNotify.override;

-		}

-		break;

-	      case MapRequest:

-		{

-		    register XMapRequestEvent *ev = (XMapRequestEvent *) re;

-		    ev->window		= sw32(event->u.mapRequest.window, sw);

-		    ev->parent		= sw32(event->u.mapRequest.parent, sw);

-		}

-		break;

-	      case ReparentNotify:

-		{

-		    register XReparentEvent *ev = (XReparentEvent *) re;

-		    ev->event		= sw32(event->u.reparent.event, sw);

-		    ev->window		= sw32(event->u.reparent.window, sw);

-		    ev->parent		= sw32(event->u.reparent.parent, sw);

-		    ev->x		= cvtINT16toInt(sw16(event->u.reparent.x, sw));

-		    ev->y		= cvtINT16toInt(sw16(event->u.reparent.y, sw));

-		    ev->override_redirect	= event->u.reparent.override;

-		}

-		break;

-	      case ConfigureNotify:

-		{

-		    register XConfigureEvent *ev = (XConfigureEvent *) re;

-		    ev->event	= sw32(event->u.configureNotify.event, sw);

-		    ev->window	= sw32(event->u.configureNotify.window, sw);

-		    ev->above	= sw32(event->u.configureNotify.aboveSibling, sw);

-		    ev->x	= cvtINT16toInt(sw16(event->u.configureNotify.x, sw));

-		    ev->y	= cvtINT16toInt(sw16(event->u.configureNotify.y, sw));

-		    ev->width	= sw16(event->u.configureNotify.width, sw);

-		    ev->height	= sw16(event->u.configureNotify.height, sw);

-		    ev->border_width  = sw16(event->u.configureNotify.borderWidth, sw);

-		    ev->override_redirect = event->u.configureNotify.override;

-		}

-		break;

-	      case ConfigureRequest:

-		{

-		    register XConfigureRequestEvent *ev =

-		        (XConfigureRequestEvent *) re;

-		    ev->window		= sw32(event->u.configureRequest.window, sw);

-		    ev->parent		= sw32(event->u.configureRequest.parent, sw);

-		    ev->above		= sw32(event->u.configureRequest.sibling, sw);

-		    ev->x		= cvtINT16toInt(sw16(event->u.configureRequest.x, sw));

-		    ev->y		= cvtINT16toInt(sw16(event->u.configureRequest.y, sw));

-		    ev->width		= sw16(event->u.configureRequest.width, sw);

-		    ev->height		= sw16(event->u.configureRequest.height, sw);

-		    ev->border_width	= sw16(event->u.configureRequest.borderWidth, sw);

-		    ev->value_mask	= sw16(event->u.configureRequest.valueMask, sw);

-		    ev->detail  	= event->u.u.detail;

-		}

-		break;

-	      case GravityNotify:

-		{

-		    register XGravityEvent *ev = (XGravityEvent *) re;

-		    ev->window		= sw32(event->u.gravity.window, sw);

-		    ev->event		= sw32(event->u.gravity.event, sw);

-		    ev->x		= cvtINT16toInt(sw16(event->u.gravity.x, sw));

-		    ev->y		= cvtINT16toInt(sw16(event->u.gravity.y, sw));

-		}

-		break;

-	      case ResizeRequest:

-		{

-		    register XResizeRequestEvent *ev =

-			(XResizeRequestEvent *) re;

-		    ev->window		= sw32(event->u.resizeRequest.window, sw);

-		    ev->width		= sw16(event->u.resizeRequest.width, sw);

-		    ev->height		= sw16(event->u.resizeRequest.height, sw);

-		}

-		break;

-	      case CirculateNotify:

-		{

-		    register XCirculateEvent *ev = (XCirculateEvent *) re;

-		    ev->window		= sw32(event->u.circulate.window, sw);

-		    ev->event		= sw32(event->u.circulate.event, sw);

-		    ev->place		= event->u.circulate.place;

-		}

-		break;

-	      case CirculateRequest:

-		{

-		    register XCirculateRequestEvent *ev =

-		        (XCirculateRequestEvent *) re;

-		    ev->window		= sw32(event->u.circulate.window, sw);

-		    ev->parent		= sw32(event->u.circulate.event, sw);

-		    ev->place		= event->u.circulate.place;

-		}

-		break;

-	      case PropertyNotify:

-		{

-		    register XPropertyEvent *ev = (XPropertyEvent *) re;

-		    ev->window		= sw32(event->u.property.window, sw);

-		    ev->atom		= sw32(event->u.property.atom, sw);

-		    ev->time		= sw32(event->u.property.time, sw);

-		    ev->state		= event->u.property.state;

-		}

-		break;

-	      case SelectionClear:

-		{

-		    register XSelectionClearEvent *ev =

-			 (XSelectionClearEvent *) re;

-		    ev->window		= sw32(event->u.selectionClear.window, sw);

-		    ev->selection	= sw32(event->u.selectionClear.atom, sw);

-		    ev->time		= sw32(event->u.selectionClear.time, sw);

-		}

-		break;

-	      case SelectionRequest:

-		{

-		    register XSelectionRequestEvent *ev =

-		        (XSelectionRequestEvent *) re;

-		    ev->owner		= sw32(event->u.selectionRequest.owner, sw);

-		    ev->requestor	= sw32(event->u.selectionRequest.requestor, sw);

-		    ev->selection	= sw32(event->u.selectionRequest.selection, sw);

-		    ev->target		= sw32(event->u.selectionRequest.target, sw);

-		    ev->property	= sw32(event->u.selectionRequest.property, sw);

-		    ev->time		= sw32(event->u.selectionRequest.time, sw);

-		}

-		break;

-	      case SelectionNotify:

-		{

-		    register XSelectionEvent *ev = (XSelectionEvent *) re;

-		    ev->requestor	= sw32(event->u.selectionNotify.requestor, sw);

-		    ev->selection	= sw32(event->u.selectionNotify.selection, sw);

-		    ev->target		= sw32(event->u.selectionNotify.target, sw);

-		    ev->property	= sw32(event->u.selectionNotify.property, sw);

-		    ev->time		= sw32(event->u.selectionNotify.time, sw);

-		}

-		break;

-	      case ColormapNotify:

-		{

-		    register XColormapEvent *ev = (XColormapEvent *) re;

-		    ev->window		= sw32(event->u.colormap.window, sw);

-		    ev->colormap	= sw32(event->u.colormap.colormap, sw);

-		    ev->new		= event->u.colormap.new;

-		    ev->state		= event->u.colormap.state;

-	        }

-		break;

-	      case ClientMessage:

-		{

-		   register int i;

-		   register XClientMessageEvent *ev

-		   			= (XClientMessageEvent *) re;

-		   ev->window		= sw32(event->u.clientMessage.window, sw);

-		   ev->format		= event->u.u.detail;

-		   switch (ev->format) {

-			case 8:

-			   ev->message_type = sw32(event->u.clientMessage.u.b.type, sw);

-			   for (i = 0; i < 20; i++)

-			     ev->data.b[i] = event->u.clientMessage.u.b.bytes[i];

-			   break;

-			case 16:

-			   ev->message_type = sw32(event->u.clientMessage.u.s.type, sw);

-			   ev->data.s[0] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts0, sw));

-			   ev->data.s[1] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts1, sw));

-			   ev->data.s[2] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts2, sw));

-			   ev->data.s[3] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts3, sw));

-			   ev->data.s[4] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts4, sw));

-			   ev->data.s[5] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts5, sw));

-			   ev->data.s[6] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts6, sw));

-			   ev->data.s[7] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts7, sw));

-			   ev->data.s[8] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts8, sw));

-			   ev->data.s[9] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts9, sw));

-			   break;

-			case 32:

-			   ev->message_type = sw32(event->u.clientMessage.u.l.type, sw);

-			   ev->data.l[0] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs0, sw));

-			   ev->data.l[1] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs1, sw));

-			   ev->data.l[2] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs2, sw));

-			   ev->data.l[3] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs3, sw));

-			   ev->data.l[4] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs4, sw));

-			   break;

-			default: /* XXX should never occur */

-				break;

-		    }

-	        }

-		break;

-	      case MappingNotify:

-		{

-		   register XMappingEvent *ev = (XMappingEvent *)re;

-		   ev->window		= 0;

-		   ev->first_keycode 	= event->u.mappingNotify.firstKeyCode;

-		   ev->request 		= event->u.mappingNotify.request;

-		   ev->count 		= event->u.mappingNotify.count;

-		}

-		break;

-	      default:

-		return(False);

-	}

-	return(True);

-}

+/***********************************************************
+Copyright 1993 by Digital Equipment Corporation, Maynard, Massachusetts,
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xlibint.h>
+#include <X11/Xlib.h>
+#include "Ximint.h"
+
+
+#define sw16(n, s) ((s) ?                    \
+		      (((n) << 8 & 0xff00) | \
+		       ((n) >> 8 & 0xff)     \
+		      ) : n)
+
+#define sw32(n, s) ((s) ?                         \
+		      (((n) << 24 & 0xff000000) | \
+		       ((n) <<  8 & 0xff0000) |   \
+		       ((n) >>  8 & 0xff00) |     \
+		       ((n) >> 24 & 0xff)         \
+		      ) : n)
+
+Status
+_XimProtoEventToWire(
+    register XEvent *re,	/* pointer to where event should be reformatted */
+    register xEvent *event,	/* wire protocol event */
+    Bool sw)         /* swap byte? */
+{
+	switch (event->u.u.type = re->type) {
+	      case KeyPress:
+	      case KeyRelease:
+	        {
+			register XKeyEvent *ev = (XKeyEvent*) re;
+			event->u.keyButtonPointer.root	= sw32(ev->root, sw);
+			event->u.keyButtonPointer.event	 =
+			    sw32(ev->window, sw);
+			event->u.keyButtonPointer.child  =
+			    sw32(ev->subwindow, sw);
+			event->u.keyButtonPointer.time	 = sw32(ev->time, sw);
+			event->u.keyButtonPointer.eventX = sw16(ev->x, sw) ;
+			event->u.keyButtonPointer.eventY = sw16(ev->y, sw) ;
+			event->u.keyButtonPointer.rootX	 =
+			    sw16(ev->x_root, sw);
+			event->u.keyButtonPointer.rootY  =
+			    sw16(ev->y_root, sw);
+			event->u.keyButtonPointer.state  = sw16(ev->state, sw);
+			event->u.keyButtonPointer.sameScreen = ev->same_screen;
+			event->u.u.detail = ev->keycode;
+		}
+	      	break;
+	      case ButtonPress:
+	      case ButtonRelease:
+	        {
+			register XButtonEvent *ev =  (XButtonEvent *) re;
+			event->u.keyButtonPointer.root	 = sw32(ev->root, sw);
+			event->u.keyButtonPointer.event	 = sw32(ev->window, sw);
+			event->u.keyButtonPointer.child	 = sw32(ev->subwindow, sw);
+			event->u.keyButtonPointer.time	 = sw32(ev->time, sw);
+			event->u.keyButtonPointer.eventX = sw16(ev->x, sw);
+			event->u.keyButtonPointer.eventY = sw16(ev->y, sw);
+			event->u.keyButtonPointer.rootX	 = sw16(ev->x_root, sw);
+			event->u.keyButtonPointer.rootY	 = sw16(ev->y_root, sw);
+			event->u.keyButtonPointer.state	 = sw16(ev->state, sw);
+			event->u.keyButtonPointer.sameScreen	= ev->same_screen;
+			event->u.u.detail		= ev->button;
+		}
+	        break;
+	      case MotionNotify:
+	        {
+			register XMotionEvent *ev =   (XMotionEvent *)re;
+			event->u.keyButtonPointer.root	= sw32(ev->root, sw);
+			event->u.keyButtonPointer.event	= sw32(ev->window, sw);
+			event->u.keyButtonPointer.child	= sw32(ev->subwindow, sw);
+			event->u.keyButtonPointer.time	= sw32(ev->time, sw);
+			event->u.keyButtonPointer.eventX= sw16(ev->x, sw);
+			event->u.keyButtonPointer.eventY= sw16(ev->y, sw);
+			event->u.keyButtonPointer.rootX	= sw16(ev->x_root, sw);
+			event->u.keyButtonPointer.rootY	= sw16(ev->y_root, sw);
+			event->u.keyButtonPointer.state	= sw16(ev->state, sw);
+			event->u.keyButtonPointer.sameScreen= ev->same_screen;
+			event->u.u.detail		= ev->is_hint;
+		}
+	        break;
+	      case EnterNotify:
+	      case LeaveNotify:
+		{
+			register XCrossingEvent *ev   = (XCrossingEvent *) re;
+			event->u.enterLeave.root	= sw32(ev->root, sw);
+			event->u.enterLeave.event	= sw32(ev->window, sw);
+			event->u.enterLeave.child	= sw32(ev->subwindow, sw);
+			event->u.enterLeave.time	= sw32(ev->time, sw);
+			event->u.enterLeave.eventX	= sw16(ev->x, sw);
+			event->u.enterLeave.eventY	= sw16(ev->y, sw);
+			event->u.enterLeave.rootX	= sw16(ev->x_root, sw);
+			event->u.enterLeave.rootY	= sw16(ev->y_root, sw);
+			event->u.enterLeave.state	= sw16(ev->state, sw);
+			event->u.enterLeave.mode	= ev->mode;
+			event->u.enterLeave.flags	= 0;
+			if (ev->same_screen) {
+				event->u.enterLeave.flags |= ELFlagSameScreen;
+				}
+			if (ev->focus) {
+				event->u.enterLeave.flags |= ELFlagFocus;
+				}
+			event->u.u.detail		= ev->detail;
+		}
+		  break;
+	      case FocusIn:
+	      case FocusOut:
+		{
+			register XFocusChangeEvent *ev = (XFocusChangeEvent *) re;
+			event->u.focus.window	= sw32(ev->window, sw);
+			event->u.focus.mode	= ev->mode;
+			event->u.u.detail	= ev->detail;
+		}
+		  break;
+	      case KeymapNotify:
+		{
+			register XKeymapEvent *ev = (XKeymapEvent *) re;
+			memcpy((char *)(((xKeymapEvent *) event)->map),
+			       &ev->key_vector[1],
+			       sizeof (((xKeymapEvent *) event)->map));
+		}
+		break;
+	      case Expose:
+		{
+			register XExposeEvent *ev = (XExposeEvent *) re;
+			event->u.expose.window		= sw32(ev->window, sw);
+			event->u.expose.x		= sw16(ev->x, sw);
+			event->u.expose.y		= sw16(ev->y, sw);
+			event->u.expose.width		= sw16(ev->width, sw);
+			event->u.expose.height		= sw16(ev->height, sw);
+			event->u.expose.count		= sw16(ev->count, sw);
+		}
+		break;
+	      case GraphicsExpose:
+		{
+		    register XGraphicsExposeEvent *ev =
+			(XGraphicsExposeEvent *) re;
+		    event->u.graphicsExposure.drawable	= sw32(ev->drawable, sw);
+		    event->u.graphicsExposure.x		= sw16(ev->x, sw);
+		    event->u.graphicsExposure.y		= sw16(ev->y, sw);
+		    event->u.graphicsExposure.width	= sw16(ev->width, sw);
+		    event->u.graphicsExposure.height	= sw16(ev->height, sw);
+		    event->u.graphicsExposure.count	= sw16(ev->count, sw);
+		    event->u.graphicsExposure.majorEvent= ev->major_code;
+		    event->u.graphicsExposure.minorEvent= sw16(ev->minor_code, sw);
+		}
+		break;
+	      case NoExpose:
+		{
+		    register XNoExposeEvent *ev = (XNoExposeEvent *) re;
+		    event->u.noExposure.drawable	= sw32(ev->drawable, sw);
+		    event->u.noExposure.majorEvent	= ev->major_code;
+		    event->u.noExposure.minorEvent	= sw16(ev->minor_code, sw);
+		}
+		break;
+	      case VisibilityNotify:
+		{
+		    register XVisibilityEvent *ev = (XVisibilityEvent *) re;
+		    event->u.visibility.window		= sw32(ev->window, sw);
+		    event->u.visibility.state		= ev->state;
+		}
+		break;
+	      case CreateNotify:
+		{
+		    register XCreateWindowEvent *ev =
+			 (XCreateWindowEvent *) re;
+		    event->u.createNotify.window	= sw32(ev->window, sw);
+		    event->u.createNotify.parent	= sw32(ev->parent, sw);
+		    event->u.createNotify.x		= sw16(ev->x, sw);
+		    event->u.createNotify.y		= sw16(ev->y, sw);
+		    event->u.createNotify.width		= sw16(ev->width, sw);
+		    event->u.createNotify.height	= sw16(ev->height, sw);
+		    event->u.createNotify.borderWidth	= sw16(ev->border_width, sw);
+		    event->u.createNotify.override	= ev->override_redirect;
+		}
+		break;
+	      case DestroyNotify:
+		{
+		    register XDestroyWindowEvent *ev =
+				(XDestroyWindowEvent *) re;
+		    event->u.destroyNotify.window	= sw32(ev->window, sw);
+		    event->u.destroyNotify.event	= sw32(ev->event, sw);
+		}
+		break;
+	      case UnmapNotify:
+		{
+		    register XUnmapEvent *ev = (XUnmapEvent *) re;
+		    event->u.unmapNotify.window	= sw32(ev->window, sw);
+		    event->u.unmapNotify.event	= sw32(ev->event, sw);
+		    event->u.unmapNotify.fromConfigure	= ev->from_configure;
+		}
+		break;
+	      case MapNotify:
+		{
+		    register XMapEvent *ev = (XMapEvent *) re;
+		    event->u.mapNotify.window	= sw32(ev->window, sw);
+		    event->u.mapNotify.event	= sw32(ev->event, sw);
+		    event->u.mapNotify.override	= ev->override_redirect;
+		}
+		break;
+	      case MapRequest:
+		{
+		    register XMapRequestEvent *ev = (XMapRequestEvent *) re;
+		    event->u.mapRequest.window	= sw32(ev->window, sw);
+		    event->u.mapRequest.parent	= sw32(ev->parent, sw);
+		}
+		break;
+	      case ReparentNotify:
+		{
+		    register XReparentEvent *ev = (XReparentEvent *) re;
+		    event->u.reparent.window	= sw32(ev->window, sw);
+		    event->u.reparent.event	= sw32(ev->event, sw);
+		    event->u.reparent.parent	= sw32(ev->parent, sw);
+		    event->u.reparent.x		= sw16(ev->x, sw);
+		    event->u.reparent.y		= sw16(ev->y, sw);
+		    event->u.reparent.override	= ev->override_redirect;
+		}
+		break;
+	      case ConfigureNotify:
+		{
+		    register XConfigureEvent *ev = (XConfigureEvent *) re;
+		    event->u.configureNotify.window	= sw32(ev->window, sw);
+		    event->u.configureNotify.event	= sw32(ev->event, sw);
+		    event->u.configureNotify.aboveSibling	= sw32(ev->above, sw);
+		    event->u.configureNotify.x		= sw16(ev->x, sw);
+		    event->u.configureNotify.y		= sw16(ev->y, sw);
+		    event->u.configureNotify.width	= sw16(ev->width, sw);
+		    event->u.configureNotify.height	= sw16(ev->height, sw);
+		    event->u.configureNotify.borderWidth= sw16(ev->border_width, sw);
+		    event->u.configureNotify.override	= ev->override_redirect;
+		}
+		break;
+	      case ConfigureRequest:
+		{
+		    register XConfigureRequestEvent *ev =
+		        (XConfigureRequestEvent *) re;
+		    event->u.configureRequest.window	= sw32(ev->window, sw);
+		    event->u.configureRequest.parent	= sw32(ev->parent, sw);
+		    event->u.configureRequest.sibling   = sw32(ev->above, sw);
+		    event->u.configureRequest.x		= sw16(ev->x, sw);
+		    event->u.configureRequest.y		= sw16(ev->y, sw);
+		    event->u.configureRequest.width	= sw16(ev->width, sw);
+		    event->u.configureRequest.height	= sw16(ev->height, sw);
+		    event->u.configureRequest.borderWidth= sw16(ev->border_width, sw);
+		    event->u.configureRequest.valueMask= sw16(ev->value_mask, sw);
+		    event->u.u.detail 			= ev->detail;
+		}
+		break;
+	      case GravityNotify:
+		{
+		    register XGravityEvent *ev  = (XGravityEvent *) re;
+		    event->u.gravity.window	= sw32(ev->window, sw);
+		    event->u.gravity.event	= sw32(ev->event, sw);
+		    event->u.gravity.x		= sw16(ev->x, sw);
+		    event->u.gravity.y		= sw16(ev->y, sw);
+		}
+		break;
+	      case ResizeRequest:
+		{
+		    register XResizeRequestEvent *ev =
+			(XResizeRequestEvent *) re;
+		    event->u.resizeRequest.window	= sw32(ev->window, sw);
+		    event->u.resizeRequest.width	= sw16(ev->width, sw);
+		    event->u.resizeRequest.height	= sw16(ev->height, sw);
+		}
+		break;
+	      case CirculateNotify:
+		{
+		    register XCirculateEvent *ev = (XCirculateEvent *) re;
+		    event->u.circulate.window		= sw32(ev->window, sw);
+		    event->u.circulate.event		= sw32(ev->event, sw);
+		    event->u.circulate.place		= ev->place;
+		}
+		break;
+	      case CirculateRequest:
+		{
+		    register XCirculateRequestEvent *ev =
+		        (XCirculateRequestEvent *) re;
+		    event->u.circulate.window		= sw32(ev->window, sw);
+		    event->u.circulate.event		= sw32(ev->parent, sw);
+		    event->u.circulate.place		= ev->place;
+		}
+		break;
+	      case PropertyNotify:
+		{
+		    register XPropertyEvent *ev = (XPropertyEvent *) re;
+		    event->u.property.window		= sw32(ev->window, sw);
+		    event->u.property.atom		= sw32(ev->atom, sw);
+		    event->u.property.time		= sw32(ev->time, sw);
+		    event->u.property.state		= ev->state;
+		}
+		break;
+	      case SelectionClear:
+		{
+		    register XSelectionClearEvent *ev =
+			 (XSelectionClearEvent *) re;
+		    event->u.selectionClear.window	= sw32(ev->window, sw);
+		    event->u.selectionClear.atom	= sw32(ev->selection, sw);
+		    event->u.selectionClear.time	= sw32(ev->time, sw);
+		}
+		break;
+	      case SelectionRequest:
+		{
+		    register XSelectionRequestEvent *ev =
+		        (XSelectionRequestEvent *) re;
+		    event->u.selectionRequest.owner	= sw32(ev->owner, sw);
+		    event->u.selectionRequest.requestor	= sw32(ev->requestor, sw);
+		    event->u.selectionRequest.selection	= sw32(ev->selection, sw);
+		    event->u.selectionRequest.target	= sw32(ev->target, sw);
+		    event->u.selectionRequest.property	= sw32(ev->property, sw);
+		    event->u.selectionRequest.time	= sw32(ev->time, sw);
+		}
+		break;
+	      case SelectionNotify:
+		{
+		    register XSelectionEvent *ev = (XSelectionEvent *) re;
+		    event->u.selectionNotify.requestor	= sw32(ev->requestor, sw);
+		    event->u.selectionNotify.selection	= sw32(ev->selection, sw);
+		    event->u.selectionNotify.target	= sw32(ev->target, sw);
+		    event->u.selectionNotify.property	= sw32(ev->property, sw);
+		    event->u.selectionNotify.time	= sw32(ev->time, sw);
+		}
+		break;
+	      case ColormapNotify:
+		{
+		    register XColormapEvent *ev = (XColormapEvent *) re;
+		    event->u.colormap.window		= sw32(ev->window, sw);
+		    event->u.colormap.colormap		= sw32(ev->colormap, sw);
+		    event->u.colormap.new		= ev->new;
+		    event->u.colormap.state		= ev->state;
+	        }
+		break;
+	      case ClientMessage:
+		{
+		   register int i;
+		   register XClientMessageEvent *ev
+		   			= (XClientMessageEvent *) re;
+		   event->u.clientMessage.window = sw32(ev->window, sw);
+		   event->u.u.detail		 = ev->format;
+		   switch (ev->format) {
+			case 8:
+			  event->u.clientMessage.u.b.type   = sw32(ev->message_type, sw);
+			  for (i = 0; i < 20; i++)
+			   event->u.clientMessage.u.b.bytes[i] = ev->data.b[i];
+			  break;
+			case 16:
+			  event->u.clientMessage.u.s.type   = sw32(ev->message_type, sw);
+			  event->u.clientMessage.u.s.shorts0   = sw16(ev->data.s[0], sw);
+			  event->u.clientMessage.u.s.shorts1   = sw16(ev->data.s[1], sw);
+			  event->u.clientMessage.u.s.shorts2   = sw16(ev->data.s[2], sw);
+			  event->u.clientMessage.u.s.shorts3   = sw16(ev->data.s[3], sw);
+			  event->u.clientMessage.u.s.shorts4   = sw16(ev->data.s[4], sw);
+			  event->u.clientMessage.u.s.shorts5   = sw16(ev->data.s[5], sw);
+			  event->u.clientMessage.u.s.shorts6   = sw16(ev->data.s[6], sw);
+			  event->u.clientMessage.u.s.shorts7   = sw16(ev->data.s[7], sw);
+			  event->u.clientMessage.u.s.shorts8   = sw16(ev->data.s[8], sw);
+			  event->u.clientMessage.u.s.shorts9   = sw16(ev->data.s[9], sw);
+			  break;
+			case 32:
+			  event->u.clientMessage.u.l.type   = sw32(ev->message_type, sw);
+			  event->u.clientMessage.u.l.longs0   = sw32(ev->data.l[0], sw);
+			  event->u.clientMessage.u.l.longs1   = sw32(ev->data.l[1], sw);
+			  event->u.clientMessage.u.l.longs2   = sw32(ev->data.l[2], sw);
+			  event->u.clientMessage.u.l.longs3   = sw32(ev->data.l[3], sw);
+			  event->u.clientMessage.u.l.longs4   = sw32(ev->data.l[4], sw);
+			  break;
+			default:
+			  /* client passing bogus data, let server complain */
+			  break;
+			}
+		    }
+		break;
+	      case MappingNotify:
+		  {
+		    register XMappingEvent *ev = (XMappingEvent *) re;
+		    event->u.mappingNotify.firstKeyCode = ev->first_keycode;
+		    event->u.mappingNotify.request 	= ev->request;
+		    event->u.mappingNotify.count	= ev->count;
+		   }
+		break;
+
+	      default:
+		return(0);
+	}
+	/* Common process */
+	if (((XAnyEvent *)re)->send_event)
+	    event->u.u.type |= 0x80;
+	event->u.u.sequenceNumber =
+	    ((XAnyEvent *)re)->serial & ~((unsigned long)0xffff);
+	event->u.u.sequenceNumber = sw16(event->u.u.sequenceNumber, sw);
+	return(1);
+}
+
+
+/*
+ * reformat a wire event into an XEvent structure of the right type.
+ */
+Bool
+_XimProtoWireToEvent(
+    register XEvent *re,	/* pointer to where event should be reformatted */
+    register xEvent *event,	/* wire protocol event */
+    Bool sw)                /* swap byte? */
+{
+
+	re->type = event->u.u.type & 0x7f;
+	((XAnyEvent *)re)->serial = sw16(event->u.u.sequenceNumber, sw);
+	((XAnyEvent *)re)->send_event = ((event->u.u.type & 0x80) != 0);
+	((XAnyEvent *)re)->display = NULL;
+
+	/* Ignore the leading bit of the event type since it is set when a
+		client sends an event rather than the server. */
+
+	switch (event-> u.u.type & 0177) {
+	      case KeyPress:
+	      case KeyRelease:
+	        {
+			register XKeyEvent *ev = (XKeyEvent*) re;
+			ev->root 	= sw32(event->u.keyButtonPointer.root, sw);
+			ev->window 	= sw32(event->u.keyButtonPointer.event, sw);
+			ev->subwindow 	= sw32(event->u.keyButtonPointer.child, sw);
+			ev->time 	= sw32(event->u.keyButtonPointer.time, sw);
+			ev->x 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventX, sw));
+			ev->y 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventY, sw));
+			ev->x_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootX, sw));
+			ev->y_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootY, sw));
+			ev->state	= sw16(event->u.keyButtonPointer.state, sw);
+			ev->same_screen	= event->u.keyButtonPointer.sameScreen;
+			ev->keycode 	= event->u.u.detail;
+		}
+	      	break;
+	      case ButtonPress:
+	      case ButtonRelease:
+	        {
+			register XButtonEvent *ev =  (XButtonEvent *) re;
+			ev->root 	= sw32(event->u.keyButtonPointer.root, sw);
+			ev->window 	= sw32(event->u.keyButtonPointer.event, sw);
+			ev->subwindow 	= sw32(event->u.keyButtonPointer.child, sw);
+			ev->time 	= sw32(event->u.keyButtonPointer.time, sw);
+			ev->x 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventX, sw));
+			ev->y 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventY, sw));
+			ev->x_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootX, sw));
+			ev->y_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootY, sw));
+			ev->state	= sw16(event->u.keyButtonPointer.state, sw);
+			ev->same_screen	= event->u.keyButtonPointer.sameScreen;
+			ev->button 	= event->u.u.detail;
+		}
+	        break;
+	      case MotionNotify:
+	        {
+			register XMotionEvent *ev =   (XMotionEvent *)re;
+			ev->root 	= sw32(event->u.keyButtonPointer.root, sw);
+			ev->window 	= sw32(event->u.keyButtonPointer.event, sw);
+			ev->subwindow 	= sw32(event->u.keyButtonPointer.child, sw);
+			ev->time 	= sw32(event->u.keyButtonPointer.time, sw);
+			ev->x 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventX, sw));
+			ev->y 		= cvtINT16toInt(sw16(event->u.keyButtonPointer.eventY, sw));
+			ev->x_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootX, sw));
+			ev->y_root 	= cvtINT16toInt(sw16(event->u.keyButtonPointer.rootY, sw));
+			ev->state	= sw16(event->u.keyButtonPointer.state, sw);
+			ev->same_screen	= event->u.keyButtonPointer.sameScreen;
+			ev->is_hint 	= event->u.u.detail;
+		}
+	        break;
+	      case EnterNotify:
+	      case LeaveNotify:
+		{
+			register XCrossingEvent *ev   = (XCrossingEvent *) re;
+			ev->root	= sw32(event->u.enterLeave.root, sw);
+			ev->window	= sw32(event->u.enterLeave.event, sw);
+			ev->subwindow	= sw32(event->u.enterLeave.child, sw);
+			ev->time	= sw32(event->u.enterLeave.time, sw);
+			ev->x		= cvtINT16toInt(sw16(event->u.enterLeave.eventX, sw));
+			ev->y		= cvtINT16toInt(sw16(event->u.enterLeave.eventY, sw));
+			ev->x_root	= cvtINT16toInt(sw16(event->u.enterLeave.rootX, sw));
+			ev->y_root	= cvtINT16toInt(sw16(event->u.enterLeave.rootY, sw));
+			ev->state	= sw16(event->u.enterLeave.state, sw);
+			ev->mode	= event->u.enterLeave.mode;
+			ev->same_screen = (event->u.enterLeave.flags &
+				ELFlagSameScreen) && True;
+			ev->focus	= (event->u.enterLeave.flags &
+			  	ELFlagFocus) && True;
+			ev->detail	= event->u.u.detail;
+		}
+		  break;
+	      case FocusIn:
+	      case FocusOut:
+		{
+			register XFocusChangeEvent *ev = (XFocusChangeEvent *) re;
+			ev->window 	= sw32(event->u.focus.window, sw);
+			ev->mode	= event->u.focus.mode;
+			ev->detail	= event->u.u.detail;
+		}
+		  break;
+	      case KeymapNotify:
+		{
+			register XKeymapEvent *ev = (XKeymapEvent *) re;
+			ev->window	= None;
+			memcpy(&ev->key_vector[1],
+			       (char *)((xKeymapEvent *) event)->map,
+			       sizeof (((xKeymapEvent *) event)->map));
+		}
+		break;
+	      case Expose:
+		{
+			register XExposeEvent *ev = (XExposeEvent *) re;
+			ev->window	= sw32(event->u.expose.window, sw);
+			ev->x		= sw16(event->u.expose.x, sw);
+			ev->y		= sw16(event->u.expose.y, sw);
+			ev->width	= sw16(event->u.expose.width, sw);
+			ev->height	= sw16(event->u.expose.height, sw);
+			ev->count	= sw16(event->u.expose.count, sw);
+		}
+		break;
+	      case GraphicsExpose:
+		{
+		    register XGraphicsExposeEvent *ev =
+			(XGraphicsExposeEvent *) re;
+		    ev->drawable	= sw32(event->u.graphicsExposure.drawable, sw);
+		    ev->x		= sw16(event->u.graphicsExposure.x, sw);
+		    ev->y		= sw16(event->u.graphicsExposure.y, sw);
+		    ev->width		= sw16(event->u.graphicsExposure.width, sw);
+		    ev->height		= sw16(event->u.graphicsExposure.height, sw);
+		    ev->count		= sw16(event->u.graphicsExposure.count, sw);
+		    ev->major_code	= event->u.graphicsExposure.majorEvent;
+		    ev->minor_code	= sw16(event->u.graphicsExposure.minorEvent, sw);
+		}
+		break;
+	      case NoExpose:
+		{
+		    register XNoExposeEvent *ev = (XNoExposeEvent *) re;
+		    ev->drawable	= sw32(event->u.noExposure.drawable, sw);
+		    ev->major_code	= event->u.noExposure.majorEvent;
+		    ev->minor_code	= sw16(event->u.noExposure.minorEvent, sw);
+		}
+		break;
+	      case VisibilityNotify:
+		{
+		    register XVisibilityEvent *ev = (XVisibilityEvent *) re;
+		    ev->window		= sw32(event->u.visibility.window, sw);
+		    ev->state		= event->u.visibility.state;
+		}
+		break;
+	      case CreateNotify:
+		{
+		    register XCreateWindowEvent *ev =
+			 (XCreateWindowEvent *) re;
+		    ev->window		= sw32(event->u.createNotify.window, sw);
+		    ev->parent		= sw32(event->u.createNotify.parent, sw);
+		    ev->x		= cvtINT16toInt(sw16(event->u.createNotify.x, sw));
+		    ev->y		= cvtINT16toInt(sw16(event->u.createNotify.y, sw));
+		    ev->width		= sw16(event->u.createNotify.width, sw);
+		    ev->height		= sw16(event->u.createNotify.height, sw);
+		    ev->border_width	= sw16(event->u.createNotify.borderWidth, sw);
+		    ev->override_redirect	= event->u.createNotify.override;
+		}
+		break;
+	      case DestroyNotify:
+		{
+		    register XDestroyWindowEvent *ev =
+				(XDestroyWindowEvent *) re;
+		    ev->window		= sw32(event->u.destroyNotify.window, sw);
+		    ev->event		= sw32(event->u.destroyNotify.event, sw);
+		}
+		break;
+	      case UnmapNotify:
+		{
+		    register XUnmapEvent *ev = (XUnmapEvent *) re;
+		    ev->window		= sw32(event->u.unmapNotify.window, sw);
+		    ev->event		= sw32(event->u.unmapNotify.event, sw);
+		    ev->from_configure	= event->u.unmapNotify.fromConfigure;
+		}
+		break;
+	      case MapNotify:
+		{
+		    register XMapEvent *ev = (XMapEvent *) re;
+		    ev->window		= sw32(event->u.mapNotify.window, sw);
+		    ev->event		= sw32(event->u.mapNotify.event, sw);
+		    ev->override_redirect	= event->u.mapNotify.override;
+		}
+		break;
+	      case MapRequest:
+		{
+		    register XMapRequestEvent *ev = (XMapRequestEvent *) re;
+		    ev->window		= sw32(event->u.mapRequest.window, sw);
+		    ev->parent		= sw32(event->u.mapRequest.parent, sw);
+		}
+		break;
+	      case ReparentNotify:
+		{
+		    register XReparentEvent *ev = (XReparentEvent *) re;
+		    ev->event		= sw32(event->u.reparent.event, sw);
+		    ev->window		= sw32(event->u.reparent.window, sw);
+		    ev->parent		= sw32(event->u.reparent.parent, sw);
+		    ev->x		= cvtINT16toInt(sw16(event->u.reparent.x, sw));
+		    ev->y		= cvtINT16toInt(sw16(event->u.reparent.y, sw));
+		    ev->override_redirect	= event->u.reparent.override;
+		}
+		break;
+	      case ConfigureNotify:
+		{
+		    register XConfigureEvent *ev = (XConfigureEvent *) re;
+		    ev->event	= sw32(event->u.configureNotify.event, sw);
+		    ev->window	= sw32(event->u.configureNotify.window, sw);
+		    ev->above	= sw32(event->u.configureNotify.aboveSibling, sw);
+		    ev->x	= cvtINT16toInt(sw16(event->u.configureNotify.x, sw));
+		    ev->y	= cvtINT16toInt(sw16(event->u.configureNotify.y, sw));
+		    ev->width	= sw16(event->u.configureNotify.width, sw);
+		    ev->height	= sw16(event->u.configureNotify.height, sw);
+		    ev->border_width  = sw16(event->u.configureNotify.borderWidth, sw);
+		    ev->override_redirect = event->u.configureNotify.override;
+		}
+		break;
+	      case ConfigureRequest:
+		{
+		    register XConfigureRequestEvent *ev =
+		        (XConfigureRequestEvent *) re;
+		    ev->window		= sw32(event->u.configureRequest.window, sw);
+		    ev->parent		= sw32(event->u.configureRequest.parent, sw);
+		    ev->above		= sw32(event->u.configureRequest.sibling, sw);
+		    ev->x		= cvtINT16toInt(sw16(event->u.configureRequest.x, sw));
+		    ev->y		= cvtINT16toInt(sw16(event->u.configureRequest.y, sw));
+		    ev->width		= sw16(event->u.configureRequest.width, sw);
+		    ev->height		= sw16(event->u.configureRequest.height, sw);
+		    ev->border_width	= sw16(event->u.configureRequest.borderWidth, sw);
+		    ev->value_mask	= sw16(event->u.configureRequest.valueMask, sw);
+		    ev->detail  	= event->u.u.detail;
+		}
+		break;
+	      case GravityNotify:
+		{
+		    register XGravityEvent *ev = (XGravityEvent *) re;
+		    ev->window		= sw32(event->u.gravity.window, sw);
+		    ev->event		= sw32(event->u.gravity.event, sw);
+		    ev->x		= cvtINT16toInt(sw16(event->u.gravity.x, sw));
+		    ev->y		= cvtINT16toInt(sw16(event->u.gravity.y, sw));
+		}
+		break;
+	      case ResizeRequest:
+		{
+		    register XResizeRequestEvent *ev =
+			(XResizeRequestEvent *) re;
+		    ev->window		= sw32(event->u.resizeRequest.window, sw);
+		    ev->width		= sw16(event->u.resizeRequest.width, sw);
+		    ev->height		= sw16(event->u.resizeRequest.height, sw);
+		}
+		break;
+	      case CirculateNotify:
+		{
+		    register XCirculateEvent *ev = (XCirculateEvent *) re;
+		    ev->window		= sw32(event->u.circulate.window, sw);
+		    ev->event		= sw32(event->u.circulate.event, sw);
+		    ev->place		= event->u.circulate.place;
+		}
+		break;
+	      case CirculateRequest:
+		{
+		    register XCirculateRequestEvent *ev =
+		        (XCirculateRequestEvent *) re;
+		    ev->window		= sw32(event->u.circulate.window, sw);
+		    ev->parent		= sw32(event->u.circulate.event, sw);
+		    ev->place		= event->u.circulate.place;
+		}
+		break;
+	      case PropertyNotify:
+		{
+		    register XPropertyEvent *ev = (XPropertyEvent *) re;
+		    ev->window		= sw32(event->u.property.window, sw);
+		    ev->atom		= sw32(event->u.property.atom, sw);
+		    ev->time		= sw32(event->u.property.time, sw);
+		    ev->state		= event->u.property.state;
+		}
+		break;
+	      case SelectionClear:
+		{
+		    register XSelectionClearEvent *ev =
+			 (XSelectionClearEvent *) re;
+		    ev->window		= sw32(event->u.selectionClear.window, sw);
+		    ev->selection	= sw32(event->u.selectionClear.atom, sw);
+		    ev->time		= sw32(event->u.selectionClear.time, sw);
+		}
+		break;
+	      case SelectionRequest:
+		{
+		    register XSelectionRequestEvent *ev =
+		        (XSelectionRequestEvent *) re;
+		    ev->owner		= sw32(event->u.selectionRequest.owner, sw);
+		    ev->requestor	= sw32(event->u.selectionRequest.requestor, sw);
+		    ev->selection	= sw32(event->u.selectionRequest.selection, sw);
+		    ev->target		= sw32(event->u.selectionRequest.target, sw);
+		    ev->property	= sw32(event->u.selectionRequest.property, sw);
+		    ev->time		= sw32(event->u.selectionRequest.time, sw);
+		}
+		break;
+	      case SelectionNotify:
+		{
+		    register XSelectionEvent *ev = (XSelectionEvent *) re;
+		    ev->requestor	= sw32(event->u.selectionNotify.requestor, sw);
+		    ev->selection	= sw32(event->u.selectionNotify.selection, sw);
+		    ev->target		= sw32(event->u.selectionNotify.target, sw);
+		    ev->property	= sw32(event->u.selectionNotify.property, sw);
+		    ev->time		= sw32(event->u.selectionNotify.time, sw);
+		}
+		break;
+	      case ColormapNotify:
+		{
+		    register XColormapEvent *ev = (XColormapEvent *) re;
+		    ev->window		= sw32(event->u.colormap.window, sw);
+		    ev->colormap	= sw32(event->u.colormap.colormap, sw);
+		    ev->new		= event->u.colormap.new;
+		    ev->state		= event->u.colormap.state;
+	        }
+		break;
+	      case ClientMessage:
+		{
+		   register int i;
+		   register XClientMessageEvent *ev
+		   			= (XClientMessageEvent *) re;
+		   ev->window		= sw32(event->u.clientMessage.window, sw);
+		   ev->format		= event->u.u.detail;
+		   switch (ev->format) {
+			case 8:
+			   ev->message_type = sw32(event->u.clientMessage.u.b.type, sw);
+			   for (i = 0; i < 20; i++)
+			     ev->data.b[i] = event->u.clientMessage.u.b.bytes[i];
+			   break;
+			case 16:
+			   ev->message_type = sw32(event->u.clientMessage.u.s.type, sw);
+			   ev->data.s[0] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts0, sw));
+			   ev->data.s[1] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts1, sw));
+			   ev->data.s[2] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts2, sw));
+			   ev->data.s[3] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts3, sw));
+			   ev->data.s[4] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts4, sw));
+			   ev->data.s[5] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts5, sw));
+			   ev->data.s[6] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts6, sw));
+			   ev->data.s[7] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts7, sw));
+			   ev->data.s[8] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts8, sw));
+			   ev->data.s[9] = cvtINT16toShort(sw16(event->u.clientMessage.u.s.shorts9, sw));
+			   break;
+			case 32:
+			   ev->message_type = sw32(event->u.clientMessage.u.l.type, sw);
+			   ev->data.l[0] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs0, sw));
+			   ev->data.l[1] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs1, sw));
+			   ev->data.l[2] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs2, sw));
+			   ev->data.l[3] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs3, sw));
+			   ev->data.l[4] = cvtINT32toLong(sw32(event->u.clientMessage.u.l.longs4, sw));
+			   break;
+			default: /* XXX should never occur */
+				break;
+		    }
+	        }
+		break;
+	      case MappingNotify:
+		{
+		   register XMappingEvent *ev = (XMappingEvent *)re;
+		   ev->window		= 0;
+		   ev->first_keycode 	= event->u.mappingNotify.firstKeyCode;
+		   ev->request 		= event->u.mappingNotify.request;
+		   ev->count 		= event->u.mappingNotify.count;
+		}
+		break;
+	      default:
+		return(False);
+	}
+	return(True);
+}
diff --git a/libX11/modules/lc/Makefile.am b/libX11/modules/lc/Makefile.am
index 82bd06017..3cad2d61c 100644
--- a/libX11/modules/lc/Makefile.am
+++ b/libX11/modules/lc/Makefile.am
@@ -1 +1 @@
-SUBDIRS=Utf8 def gen xlocale

+SUBDIRS=Utf8 def gen xlocale
diff --git a/libX11/modules/lc/Utf8/Makefile.am b/libX11/modules/lc/Utf8/Makefile.am
index 01ad75185..50049c2f0 100644
--- a/libX11/modules/lc/Utf8/Makefile.am
+++ b/libX11/modules/lc/Utf8/Makefile.am
@@ -1,34 +1,34 @@
-AM_CPPFLAGS= \

-	-I$(top_srcdir)/include \

-	-I$(top_srcdir)/include/X11 \

-	-I$(top_builddir)/include \

-	-I$(top_builddir)/include/X11 \

-	-I$(top_srcdir)/src/xcms \

-	-I$(top_srcdir)/src/xkb \

-	-I$(top_srcdir)/src/xlibi18n \

-	-D_BSD_SOURCE

-

-AM_CFLAGS= \

-	$(X11_CFLAGS) \

-	$(BIGFONT_CFLAGS) \

-	$(MALLOC_ZERO_CFLAGS) \

-	$(CWARNFLAGS)

-

-if XLIB_LOADABLE_I18N

-

-commonlibdir = $(X11_LOCALELIBDIR)/common

-commonlib_LTLIBRARIES=xlcUTF8Load.la

-xlcUTF8Load_la_LDFLAGS = -module -version-number 2:0:0

-xlcUTF8Load_la_LIBADD = $(I18N_MODULE_LIBS)

-

-else

-

-noinst_LTLIBRARIES = libxlcUTF8Load.la

-

-endif

-

-

-xlcUTF8Load_la_SOURCES = \

-	lcUTF8Load.c

-

-libxlcUTF8Load_la_SOURCES = $(xlcUTF8Load_la_SOURCES)

+AM_CPPFLAGS= \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/include/X11 \
+	-I$(top_builddir)/include \
+	-I$(top_builddir)/include/X11 \
+	-I$(top_srcdir)/src/xcms \
+	-I$(top_srcdir)/src/xkb \
+	-I$(top_srcdir)/src/xlibi18n \
+	-D_BSD_SOURCE
+
+AM_CFLAGS= \
+	$(X11_CFLAGS) \
+	$(BIGFONT_CFLAGS) \
+	$(MALLOC_ZERO_CFLAGS) \
+	$(CWARNFLAGS)
+
+if XLIB_LOADABLE_I18N
+
+commonlibdir = $(X11_LOCALELIBDIR)/common
+commonlib_LTLIBRARIES=xlcUTF8Load.la
+xlcUTF8Load_la_LDFLAGS = -module -version-number 2:0:0
+xlcUTF8Load_la_LIBADD = $(I18N_MODULE_LIBS)
+
+else
+
+noinst_LTLIBRARIES = libxlcUTF8Load.la
+
+endif
+
+
+xlcUTF8Load_la_SOURCES = \
+	lcUTF8Load.c
+
+libxlcUTF8Load_la_SOURCES = $(xlcUTF8Load_la_SOURCES)
diff --git a/libX11/modules/lc/Utf8/lcUTF8Load.c b/libX11/modules/lc/Utf8/lcUTF8Load.c
index c1eec3749..82ea3b54d 100644
--- a/libX11/modules/lc/Utf8/lcUTF8Load.c
+++ b/libX11/modules/lc/Utf8/lcUTF8Load.c
@@ -1,70 +1,70 @@
-/******************************************************************

-

-              Copyright 1993 by SunSoft, Inc.

-              Copyright 1999-2000 by Bruno Haible

-

-Permission to use, copy, modify, distribute, and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and

-that both that copyright notice and this permission notice appear

-in supporting documentation, and that the names of SunSoft, Inc. and

-Bruno Haible not be used in advertising or publicity pertaining to

-distribution of the software without specific, written prior

-permission.  SunSoft, Inc. and Bruno Haible make no representations

-about the suitability of this software for any purpose.  It is

-provided "as is" without express or implied warranty.

-

-SunSoft Inc. AND Bruno Haible DISCLAIM ALL WARRANTIES WITH REGARD

-TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

-AND FITNESS, IN NO EVENT SHALL SunSoft, Inc. OR Bruno Haible BE LIABLE

-FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT

-OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

-******************************************************************/

-

-/*

- * This file contains the UTF-8 locale loader.

- *     Supports: all locales with codeset UTF-8.

- *     Platforms: all systems.

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include <stdio.h>

-#include "Xlibint.h"

-#include "XlcPubI.h"

-#include "XlcGeneric.h"

-

-XLCd

-_XlcUtf8Loader(

-    const char *name)

-{

-    XLCd lcd;

-

-    lcd = _XlcCreateLC(name, _XlcGenericMethods);

-    if (lcd == (XLCd) NULL)

-	return lcd;

-

-    /* The official IANA name for UTF-8 is "UTF-8" in upper case with a dash. */

-    if (!XLC_PUBLIC_PART(lcd)->codeset) {

-	_XlcDestroyLC(lcd);

-	return (XLCd) NULL;

-    }

-    else if (!_XlcCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "UTF-8")) {

-        _XlcAddUtf8LocaleConverters(lcd);

-    }

-    else if (!_XlcCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "GB18030")) {

-        _XlcAddGB18030LocaleConverters(lcd);

-    }

-    else {

-	_XlcDestroyLC(lcd);

-	return (XLCd) NULL;

-    }

-

-    _XlcAddUtf8Converters(lcd);

-

-    return lcd;

-}

+/******************************************************************
+
+              Copyright 1993 by SunSoft, Inc.
+              Copyright 1999-2000 by Bruno Haible
+
+Permission to use, copy, modify, distribute, and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear
+in supporting documentation, and that the names of SunSoft, Inc. and
+Bruno Haible not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.  SunSoft, Inc. and Bruno Haible make no representations
+about the suitability of this software for any purpose.  It is
+provided "as is" without express or implied warranty.
+
+SunSoft Inc. AND Bruno Haible DISCLAIM ALL WARRANTIES WITH REGARD
+TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS, IN NO EVENT SHALL SunSoft, Inc. OR Bruno Haible BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/*
+ * This file contains the UTF-8 locale loader.
+ *     Supports: all locales with codeset UTF-8.
+ *     Platforms: all systems.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include "Xlibint.h"
+#include "XlcPubI.h"
+#include "XlcGeneric.h"
+
+XLCd
+_XlcUtf8Loader(
+    const char *name)
+{
+    XLCd lcd;
+
+    lcd = _XlcCreateLC(name, _XlcGenericMethods);
+    if (lcd == (XLCd) NULL)
+	return lcd;
+
+    /* The official IANA name for UTF-8 is "UTF-8" in upper case with a dash. */
+    if (!XLC_PUBLIC_PART(lcd)->codeset) {
+	_XlcDestroyLC(lcd);
+	return (XLCd) NULL;
+    }
+    else if (!_XlcCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "UTF-8")) {
+        _XlcAddUtf8LocaleConverters(lcd);
+    }
+    else if (!_XlcCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "GB18030")) {
+        _XlcAddGB18030LocaleConverters(lcd);
+    }
+    else {
+	_XlcDestroyLC(lcd);
+	return (XLCd) NULL;
+    }
+
+    _XlcAddUtf8Converters(lcd);
+
+    return lcd;
+}
diff --git a/libX11/modules/lc/def/Makefile.am b/libX11/modules/lc/def/Makefile.am
index b9bd31d6d..3307077a0 100644
--- a/libX11/modules/lc/def/Makefile.am
+++ b/libX11/modules/lc/def/Makefile.am
@@ -1,32 +1,32 @@
-AM_CPPFLAGS= \

-	-I$(top_srcdir)/include \

-	-I$(top_srcdir)/include/X11 \

-	-I$(top_builddir)/include \

-	-I$(top_builddir)/include/X11 \

-	-I$(top_srcdir)/src/xcms \

-	-I$(top_srcdir)/src/xkb \

-	-I$(top_srcdir)/src/xlibi18n \

-	-D_BSD_SOURCE

-

-AM_CFLAGS= \

-	$(X11_CFLAGS) \

-	$(BIGFONT_CFLAGS) \

-	$(CWARNFLAGS)

-

-if XLIB_LOADABLE_I18N

-

-commonlibdir = $(X11_LOCALELIBDIR)/common

-commonlib_LTLIBRARIES=xlcDef.la

-xlcDef_la_LDFLAGS = -module -version-number 2:0:0

-xlcDef_la_LIBADD = $(I18N_MODULE_LIBS)

-

-else

-

-noinst_LTLIBRARIES = libxlcDef.la

-

-endif

-

-xlcDef_la_SOURCES = \

-	lcDefConv.c

-

-libxlcDef_la_SOURCES = $(xlcDef_la_SOURCES)

+AM_CPPFLAGS= \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/include/X11 \
+	-I$(top_builddir)/include \
+	-I$(top_builddir)/include/X11 \
+	-I$(top_srcdir)/src/xcms \
+	-I$(top_srcdir)/src/xkb \
+	-I$(top_srcdir)/src/xlibi18n \
+	-D_BSD_SOURCE
+
+AM_CFLAGS= \
+	$(X11_CFLAGS) \
+	$(BIGFONT_CFLAGS) \
+	$(CWARNFLAGS)
+
+if XLIB_LOADABLE_I18N
+
+commonlibdir = $(X11_LOCALELIBDIR)/common
+commonlib_LTLIBRARIES=xlcDef.la
+xlcDef_la_LDFLAGS = -module -version-number 2:0:0
+xlcDef_la_LIBADD = $(I18N_MODULE_LIBS)
+
+else
+
+noinst_LTLIBRARIES = libxlcDef.la
+
+endif
+
+xlcDef_la_SOURCES = \
+	lcDefConv.c
+
+libxlcDef_la_SOURCES = $(xlcDef_la_SOURCES)
diff --git a/libX11/modules/lc/gen/Makefile.am b/libX11/modules/lc/gen/Makefile.am
index 91004a3c5..8ed02a5ad 100644
--- a/libX11/modules/lc/gen/Makefile.am
+++ b/libX11/modules/lc/gen/Makefile.am
@@ -1,32 +1,32 @@
-AM_CPPFLAGS= \

-	-I$(top_srcdir)/include \

-	-I$(top_srcdir)/include/X11 \

-	-I$(top_builddir)/include \

-	-I$(top_builddir)/include/X11 \

-	-I$(top_srcdir)/src/xcms \

-	-I$(top_srcdir)/src/xkb \

-	-I$(top_srcdir)/src/xlibi18n \

-	-D_BSD_SOURCE

-

-AM_CFLAGS= \

-	$(X11_CFLAGS) \

-	$(BIGFONT_CFLAGS) \

-	$(CWARNFLAGS)

-

-if XLIB_LOADABLE_I18N

-

-commonlibdir = $(X11_LOCALELIBDIR)/common

-commonlib_LTLIBRARIES=xlibi18n.la

-xlibi18n_la_LDFLAGS = -module -version-number 2:0:0

-xlibi18n_la_LIBADD = $(I18N_MODULE_LIBS)

-

-else

-

-noinst_LTLIBRARIES = libxlibi18n.la

-

-endif

-

-xlibi18n_la_SOURCES = \

-	lcGenConv.c

-

-libxlibi18n_la_SOURCES = $(xlibi18n_la_SOURCES)

+AM_CPPFLAGS= \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/include/X11 \
+	-I$(top_builddir)/include \
+	-I$(top_builddir)/include/X11 \
+	-I$(top_srcdir)/src/xcms \
+	-I$(top_srcdir)/src/xkb \
+	-I$(top_srcdir)/src/xlibi18n \
+	-D_BSD_SOURCE
+
+AM_CFLAGS= \
+	$(X11_CFLAGS) \
+	$(BIGFONT_CFLAGS) \
+	$(CWARNFLAGS)
+
+if XLIB_LOADABLE_I18N
+
+commonlibdir = $(X11_LOCALELIBDIR)/common
+commonlib_LTLIBRARIES=xlibi18n.la
+xlibi18n_la_LDFLAGS = -module -version-number 2:0:0
+xlibi18n_la_LIBADD = $(I18N_MODULE_LIBS)
+
+else
+
+noinst_LTLIBRARIES = libxlibi18n.la
+
+endif
+
+xlibi18n_la_SOURCES = \
+	lcGenConv.c
+
+libxlibi18n_la_SOURCES = $(xlibi18n_la_SOURCES)
diff --git a/libX11/modules/lc/xlocale/Makefile.am b/libX11/modules/lc/xlocale/Makefile.am
index ce1fd0976..70a221fd7 100644
--- a/libX11/modules/lc/xlocale/Makefile.am
+++ b/libX11/modules/lc/xlocale/Makefile.am
@@ -1,35 +1,35 @@
-AM_CPPFLAGS= \

-	-I$(top_srcdir)/include \

-	-I$(top_srcdir)/include/X11 \

-	-I$(top_builddir)/include \

-	-I$(top_builddir)/include/X11 \

-	-I$(top_srcdir)/src/xcms \

-	-I$(top_srcdir)/src/xkb \

-	-I$(top_srcdir)/src/xlibi18n \

-	-D_BSD_SOURCE

-

-AM_CFLAGS= \

-	$(X11_CFLAGS) \

-	$(BIGFONT_CFLAGS) \

-	$(CWARNFLAGS)

-

-if XLIB_LOADABLE_I18N

-

-commonlibdir = $(X11_LOCALELIBDIR)/common

-commonlib_LTLIBRARIES=xlocale.la

-xlocale_la_LDFLAGS = -module -version-number 2:0:0

-xlocale_la_LIBADD = $(I18N_MODULE_LIBS)

-

-else

-

-noinst_LTLIBRARIES = libxlocale.la

-

-endif

-

-

-xlocale_la_SOURCES = \

-	lcEuc.c \

-	lcJis.c \

-	lcSjis.c

-	

-libxlocale_la_SOURCES = $(xlocale_la_SOURCES)

+AM_CPPFLAGS= \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/include/X11 \
+	-I$(top_builddir)/include \
+	-I$(top_builddir)/include/X11 \
+	-I$(top_srcdir)/src/xcms \
+	-I$(top_srcdir)/src/xkb \
+	-I$(top_srcdir)/src/xlibi18n \
+	-D_BSD_SOURCE
+
+AM_CFLAGS= \
+	$(X11_CFLAGS) \
+	$(BIGFONT_CFLAGS) \
+	$(CWARNFLAGS)
+
+if XLIB_LOADABLE_I18N
+
+commonlibdir = $(X11_LOCALELIBDIR)/common
+commonlib_LTLIBRARIES=xlocale.la
+xlocale_la_LDFLAGS = -module -version-number 2:0:0
+xlocale_la_LIBADD = $(I18N_MODULE_LIBS)
+
+else
+
+noinst_LTLIBRARIES = libxlocale.la
+
+endif
+
+
+xlocale_la_SOURCES = \
+	lcEuc.c \
+	lcJis.c \
+	lcSjis.c
+	
+libxlocale_la_SOURCES = $(xlocale_la_SOURCES)
diff --git a/libX11/modules/lc/xlocale/lcEuc.c b/libX11/modules/lc/xlocale/lcEuc.c
index b39050578..442e3090f 100644
--- a/libX11/modules/lc/xlocale/lcEuc.c
+++ b/libX11/modules/lc/xlocale/lcEuc.c
@@ -1,1537 +1,1537 @@
-/******************************************************************

-

-        Copyright 1992, 1993 by FUJITSU LIMITED

-        Copyright 1993 by Fujitsu Open Systems Solutions, Inc.

-

-Permission to use, copy, modify, distribute and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and

-that both that copyright notice and this permission notice appear

-in supporting documentation, and that the name of FUJITSU LIMITED and

-Fujitsu Open Systems Solutions, Inc. not be used in advertising or

-publicity pertaining to distribution of the software without specific,

-written prior permission.

-FUJITSU LIMITED and Fujitsu Open Systems Solutions, Inc. makes no

-representations about the suitability of this software for any purpose.

-It is provided "as is" without express or implied warranty.

-

-FUJITSU LIMITED AND FUJITSU OPEN SYSTEMS SOLUTIONS, INC. DISCLAIMS ALL

-WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES

-OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL FUJITSU OPEN SYSTEMS

-SOLUTIONS, INC. AND FUJITSU LIMITED BE LIABLE FOR ANY SPECIAL, INDIRECT

-OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF

-USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

-OF THIS SOFTWARE.

-

-    Authors: Shigeru Yamada 		(yamada@ossi.com)

-             Jeffrey Bloomfield		(jeffb@ossi.com)

-             Yoshiyuki Segawa		(segawa@ossi.com)

-

-*****************************************************************/

-

-/*

- * An EUC locale.

- * Supports: all locales with codeset eucJP, eucKR, eucCN, eucTW.

- * How: Provides converters for euc*.

- * Platforms: Only those defining X_LOCALE (only Lynx, Linux-libc5, OS/2).

- */

-

-#ifdef X_LOCALE

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XlcGeneric.h"

-

-#include <ctype.h>

-#ifdef WIN32

-#define isascii __isascii

-#endif

-

-#define CS0     codesets[0]             /* Codeset 0 - 7-bit ASCII      */

-#define CS1     codesets[1]             /* Codeset 1 - Kanji            */

-#define CS2     codesets[2]             /* Codeset 2 - Half-Kana        */

-#define CS3     codesets[3]             /* Codeset 3 - User defined     */

-

-#define SS2	0x8e	/* Single-shift char: CS2 */

-#define SS3	0x8f    /* Single-shift char: CS3 */

-

-#define ASCII_CODESET   0

-#define KANJI_CODESET   1

-#define KANA_CODESET    2

-#define USERDEF_CODESET 3

-#define MAX_CODESETS

-

-#define GR	0x80	/* begins right-side (non-ascii) region */

-#define GL	0x7f    /* ends left-side (ascii) region        */

-

-#define isleftside(c)	(((c) & GR) ? 0 : 1)

-#define isrightside(c)	(!isleftside(c))

-

-#define BIT8OFF(c)	((c) & GL)

-#define BIT8ON(c)	((c) | GR)

-

-typedef unsigned char   Uchar;

-typedef unsigned long   Ulong;

-typedef unsigned int	Uint;

-

-static CodeSet GetCodeSetFromCharSet (XLCd lcd, XlcCharSet charset);

-static CodeSet wc_codeset (XLCd lcd, wchar_t wch);

-

-#define BADCHAR(min_ch, c)  (BIT8OFF(c) < (char)min_ch && BIT8OFF(c) != 0x0 && \

-			     BIT8OFF(c) != '\t' && BIT8OFF(c) != '\n' && \

-			     BIT8OFF(c) != 0x1b)

-

-/*

- * Notes:

- * 1. Defining FORCE_INDIRECT_CONVERTER (see _XlcEucLoader())

- *    forces indirect (charset) conversions (e.g. wcstocs()<->cstombs()).

- * 2. Using direct converters (e.g. mbstowcs()) decreases conversion

- *    times by 20-40% (depends on specific converter used).

- */

-

-static int

-euc_mbstowcs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-

-    Uchar ch;

-    int chr_len = 0;

-    int sshift =  False;

-    int shift_mult = 0;

-    Uint chrcode;

-

-    Uint wc_encode = 0;

-    Uint wc_tmp = 0;

-

-    int cs0flg = False;

-    int cs1flg = False;

-    int length = 0;

-    int unconv_num = 0;

-

-    Bool new_char;

-

-    const char *inbufptr = *from;

-    wchar_t *outbufptr = (wchar_t *) *to;

-

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-    int codeset_num = XLC_GENERIC(lcd, codeset_num);

-    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);

-

-    for (new_char = True; *from_left > 0 && *to_left > 0;) {

-

-	ch = *inbufptr++;

-

-	if (isleftside(ch)) {				/* CS0 */

-            if (ASCII_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    if( cs0flg == True) {

-		new_char = True;

-		cs0flg = False;

-	    }

-	    length = CS0->length;

-	    *outbufptr++ = (wchar_t)ch;

-	    (*from_left)--;

-	    (*to_left)--;

-	    continue;

-	}

-	else if (ch == SS2) {				/* CS2 */

-	    if (KANA_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    if (sshift == True || cs1flg == True) {

-		cs1flg = False;

-		unconv_num++;

-		continue;

-	    }

-	    length = CS2->length;

-	    wc_encode = CS2->wc_encoding;

-	    chrcode = 0;

-	    sshift = True;

-	    cs0flg = True;

-	    (*from_left)--;

-	    continue;

-	}

-	else if (ch == SS3) {				/* CS3 */

-	    if (USERDEF_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    if (sshift == True || cs1flg == True) {

-		cs1flg = False;

-		unconv_num++;

-		continue;

-	    }

-	    length = CS3->length;

-	    if (*from_left < 1 )

-		unconv_num++;

-	    wc_encode = CS3->wc_encoding;

-	    chrcode = 0;

-	    sshift = True;

-	    cs0flg = True;

-	    (*from_left)--;

-	    continue;

-

-	} else {					/* CS1 */

-	    if (KANJI_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    if (sshift == False) {

-		length = CS1->length;

-		if (*from_left < 1)

-		    unconv_num++;

-		wc_encode = CS1->wc_encoding;

-	    }

-	    chrcode = BIT8OFF(ch);

-	    cs0flg = True;

-	    cs1flg = True;

-	    (*from_left)--;

-	}

-

-	if (new_char) {				/* begin new character */

-	    chr_len = length;

-	    shift_mult = length - 1;

-	    new_char = False;

-	}

-

-	chrcode <<= (wc_shift * shift_mult);

-	shift_mult--;

-	wc_tmp |= chrcode;

-

-	if (--chr_len == 0) {

-	    wc_tmp |= wc_encode;

-	    *outbufptr++ = wc_tmp;

-	    (*to_left)--;

-

-	    new_char = True;

-	    sshift = False;

-	    cs0flg = False;

-	    cs1flg = False;

-	    wc_tmp  = (Uint)0;

-	}

-

-    }	/* end for */

-

-    *to = (XPointer)outbufptr;

-

-    if (cs0flg == True || cs1flg == True)	/* error check on last char */

-	unconv_num++;

-

-    return unconv_num;

-}

-

-

-static int

-euc_wcstombs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    const wchar_t *inbufptr = (const wchar_t *) *from;

-    XPointer outbufptr = *to;

-    wchar_t  wch;

-    int length;

-    Uchar tmp;

-    int unconv_num = 0;

-

-    XLCd lcd = (XLCd)conv->state;

-    CodeSet codeset;

-    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);

-

-    for (; *from_left > 0 && *to_left > 0; (*from_left)-- ) {

-

-	wch = *inbufptr++;

-

-	if (!(codeset = wc_codeset(lcd, wch))) {

-	    unconv_num++;

-	    (*from_left)--;

-	    continue;

-	}

-

-	length = codeset->length;

-	wch ^= (wchar_t)codeset->wc_encoding;

-

-	if (codeset->parse_info) {	/* put out SS2 or SS3 */

-	    if (*to_left < length + 1) {

-	        unconv_num++;

-		break;

-	    }

-	    *outbufptr++ = *codeset->parse_info->encoding;

-	    (*to_left)--;

-        } else {

-	    if (*to_left < length) {

-		unconv_num++;

-		break;

-	    }

-	}

-

-	do {

-	    length--;

-	    tmp = (wch>>(wchar_t)(length * wc_shift));

-

-	    if (codeset->side == XlcGR)

-		tmp = BIT8ON(tmp);

-

-	    *outbufptr++ = (Uchar)tmp;

-	    (*to_left)--;

-	} while (length);

-    }

-

-    *to = (XPointer)outbufptr;

-

-    return unconv_num;

-}

-

-

-static int

-euc_mbtocs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-    XlcCharSet charset;

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-    int codeset_num = XLC_GENERIC(lcd, codeset_num);

-    int length;

-    int unconv_num = 0;

-    int min_ch = 0;

-    const char *src = *from;

-    char *dst = *to;

-

-    if (isleftside(*src)) { 			/* 7-bit (CS0) */

-	if (ASCII_CODESET >= codeset_num)

-	    return -1;

-	charset = *CS0->charset_list;

-    }

-    else if ((Uchar)*src == SS2) {		/* half-kana (CS2) */

-	if (KANA_CODESET >= codeset_num)

-	    return -1;

-	charset = *CS2->charset_list;

-	src++;

-	(*from_left)--;

-    }

-    else if ((Uchar)*src == SS3) {		/* user-def */

-	if (USERDEF_CODESET >= codeset_num)

-	    return -1;

-	charset = *CS3->charset_list;

-	src++;

-	(*from_left)--;

-    }

-    else  { 					/* Kanji (CS1) */

-	if (KANJI_CODESET >= codeset_num)

-	    return -1;

-	charset = *CS1->charset_list;

-    }

-

-    if(*from_left < charset->char_size || *to_left < charset->char_size)

-	return -1;

-

-    min_ch = 0x20;

-    if (charset->set_size == 94)

-	if (charset->char_size > 1 || charset->side == XlcGR)

-	    min_ch = 0x21;

-

-    length = charset->char_size;

-    do {

-	if(BADCHAR(min_ch, *src)) {

-	    unconv_num++;

-	    src++;

-	    break;

-	}

-	switch (charset->side) {

-	    case XlcGL:

-		*dst++ = BIT8OFF(*src++);

-		break;

-	    case XlcGR:

-		*dst++ = BIT8ON(*src++);

-		break;

-	    default:

-		*dst++ = *src++;

-		break;

-	    }

-    } while (--length);

-

-    *to = dst;

-    *from = (XPointer) src;

-    *from_left -= charset->char_size;

-    *to_left -= charset->char_size - length;

-

-    if (num_args > 0)

-	*((XlcCharSet *) args[0]) = charset;

-

-    return unconv_num;

-}

-

-

-static int

-euc_mbstocs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    const char *tmp_from;

-    char *tmp_to;

-    int tmp_from_left, tmp_to_left;

-    XlcCharSet charset, tmp_charset;

-    XPointer tmp_args[1];

-    int unconv_num = 0, ret;

-

-/* Determine the charset of the segment and convert one characater: */

-

-    tmp_args[0] = (XPointer) &charset; /* charset from euc_mbtocs() */

-    while

-      ((ret = euc_mbtocs(conv, from, from_left, to, to_left, tmp_args, 1)) > 0)

-	unconv_num += ret;

-    if ( ret < 0 )

-	return ret;

-

-    tmp_from = *from;

-    tmp_from_left = *from_left;

-    tmp_to_left = *to_left;

-    tmp_to = *to;

-

-/* Convert remainder of the segment: */

-

-    tmp_args[0] = (XPointer) &tmp_charset;

-    while( (ret = euc_mbtocs(conv, (XPointer *) &tmp_from, &tmp_from_left,

-		     (XPointer *) &tmp_to, &tmp_to_left, tmp_args, 1)) >= 0 ) {

-

-	if (ret > 0) {

-	    unconv_num += ret;

-	    continue;

-	}

-

-	if (tmp_charset != charset)  /* quit on end of segment */

-	    break;

-

-	*from = (XPointer) tmp_from;

-	*from_left = tmp_from_left;

-	*to = (XPointer) tmp_to;

-	*to_left = tmp_to_left;

-    }

-

-    if (num_args > 0)

-	*((XlcCharSet *) args[0]) = charset;

-

-    return unconv_num;

-}

-

-

-static int

-euc_wcstocs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-    const wchar_t *wcptr = (const wchar_t *) *from;

-    char *bufptr = (char *) *to;

-    wchar_t wch;

-    char *tmpptr;

-    int length;

-    CodeSet codeset;

-    Ulong wc_encoding;

-    int wcstr_len = *from_left, buf_len = *to_left;

-

-    if (!(codeset = wc_codeset(lcd, *wcptr)))

-	return -1;

-

-    wc_encoding = codeset->wc_encoding;

-

-    if (wcstr_len < buf_len / codeset->length)

-	buf_len = wcstr_len * codeset->length;

-

-    for ( ; wcstr_len > 0 && buf_len > 0; wcptr++, wcstr_len--) {

-	wch = *wcptr;

-

-	if ((wch & XLC_GENERIC(lcd, wc_encode_mask)) != wc_encoding)

-	    break;

-

-	length = codeset->length;

-

-	buf_len -= length;

-	bufptr += length;

-	tmpptr = bufptr - 1;

-

-	while (length--) {

-	    *tmpptr-- = codeset->length == 1 && codeset->side == XlcGR ?

-	      BIT8ON(wch) : BIT8OFF(wch);

-	    wch >>= (wchar_t)XLC_GENERIC(lcd, wc_shift_bits);

-	}

-    }

-

-    if (num_args > 0)

-	*((XlcCharSet *) args[0]) = *codeset->charset_list;

-

-    *from_left -= wcptr - (wchar_t *) *from;

-    *from = (XPointer) wcptr;

-

-    *to_left -= bufptr - *to;

-    *to = bufptr;

-

-    return 0;

-}

-

-

-static int

-euc_cstombs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-    const char *csptr = *from;

-    char *bufptr = *to;

-    int csstr_len = *from_left;

-    int buf_len = *to_left;

-    int length;

-    CodeSet codeset;

-    int cvt_length;

-

-    if (num_args < 1)

-	return -1;

-

-    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))

-	return -1;

-

-    cvt_length = 0;

-    csstr_len /= codeset->length;

-    buf_len /= codeset->length;

-

-    if (codeset->parse_info)

-	csstr_len *= 2;

-

-    if (csstr_len < buf_len)

-	buf_len = csstr_len;

-

-    cvt_length += buf_len * codeset->length;

-

-    if (bufptr) {

-	while (buf_len--) {

-	    if (codeset->parse_info)	/* put out SS2 or SS3 */

-		*bufptr++ = *codeset->parse_info->encoding;

-

-	    length = codeset->length;

-	    while (length--)

-		*bufptr++ = codeset->side == XlcGR ?

-		  BIT8ON(*csptr++) : BIT8OFF(*csptr++);

-	}

-    }

-

-    *from_left -= csptr - *from;

-    *from = (XPointer) csptr;

-    if (bufptr)

-	*to += cvt_length;

-    *to_left -= cvt_length;

-

-    return 0;

-}

-

-

-static int

-euc_cstowcs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-    const char *csptr = *from;

-    wchar_t *bufptr = (wchar_t *) *to;

-    wchar_t *toptr = (wchar_t *) *to;

-    int csstr_len = *from_left;

-    int buf_len = *to_left;

-    wchar_t wch;

-    int length;

-    Ulong wc_shift_bits = XLC_GENERIC(lcd, wc_shift_bits);

-    CodeSet codeset;

-

-    if (num_args < 1)

-	return -1;

-

-    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))

-        return -1;

-

-    csstr_len /= codeset->length;

-    if (csstr_len < buf_len)

-	buf_len = csstr_len;

-    *to_left -= buf_len;

-

-    if (bufptr) {

-

-	toptr += buf_len;

-	*to = (XPointer) toptr;

-

-        while (buf_len--) {

-

-            wch = (wchar_t) BIT8OFF(*csptr);

-            csptr++;

-

-            length = codeset->length - 1;

-            while (length--) {

-                wch = (wch << wc_shift_bits) | BIT8OFF(*csptr);

-                csptr++;

-            }

-            *bufptr++ = wch | codeset->wc_encoding;

-        }

-    }

-    *from_left -= csptr - *from;

-    *from = (XPointer) csptr;

-

-    return 0;

-}

-

-

-static CodeSet

-wc_codeset(

-    XLCd lcd,

-    wchar_t wch)

-{

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-    int end = XLC_GENERIC(lcd, codeset_num);

-    Ulong widech = (Ulong)(wch & XLC_GENERIC(lcd, wc_encode_mask));

-

-    for (; --end >= 0; codesets++)

-	if ( widech == (*codesets)->wc_encoding )

-	    return *codesets;

-

-    return NULL;

-}

-

-

-static CodeSet

-GetCodeSetFromCharSet(

-    XLCd lcd,

-    XlcCharSet charset)

-{

-    CodeSet *codeset = XLC_GENERIC(lcd, codeset_list);

-    XlcCharSet *charset_list;

-    int codeset_num, num_charsets;

-

-    codeset_num = XLC_GENERIC(lcd, codeset_num);

-

-    for ( ; codeset_num-- > 0; codeset++) {

-	num_charsets = (*codeset)->num_charsets;

-	charset_list = (*codeset)->charset_list;

-

-	for ( ; num_charsets-- > 0; charset_list++)

-	    if (*charset_list == charset)

-		return *codeset;

-    }

-

-    return (CodeSet) NULL;

-}

-

-

-static XlcConv

-create_conv(

-    XLCd lcd,

-    XlcConvMethods methods)

-{

-    XlcConv conv;

-

-    conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));

-    if (conv == NULL)

-	return (XlcConv) NULL;

-

-    conv->methods = methods;

-    conv->state = (XPointer) lcd;

-    return conv;

-}

-

-

-/*

- *    Stripped down Direct CT converters for EUC

- *

- */

-

-typedef struct _CTDataRec {

-    int side;

-    int length;

-    char *name;

-    Ulong wc_encoding;

-    char sshift;

-    char *ct_encoding;

-    int ct_encoding_len;

-    int set_size;

-    Uchar min_ch;

-    Uchar ct_type;

-} CTDataRec, *CTData;

-

-typedef struct _StateRec {

-    CTData GL_charset;

-    CTData GR_charset;

-    CTData charset;

-} StateRec, *State;

-

-#define CT_STD  0

-#define CT_NSTD 1

-#define CT_DIR  2

-#define CT_EXT0 3

-#define CT_EXT1 4

-#define CT_EXT2 5

-#define CT_VER  6

-

-static CTDataRec ctdata[] =

-{

-  { XlcGL,      1, "ISO8859-1:GL",       0, 0, "\033(B"   ,  3, 0, 0, CT_STD  },

-  { XlcGR,      1, "ISO8859-1:GR",       0, 0, "\033-A"   ,  3, 0, 0, CT_STD  },

-  { XlcGL,      1, "JISX0201.1976-0:GL", 0, 0, "\033(J"   ,  3, 0, 0, CT_STD  },

-  { XlcGR,      1, "JISX0201.1976-0:GR", 0, 0, "\033)I"   ,  3, 0, 0, CT_STD  },

-  { XlcGL,      2, "JISX0208.1983-0:GL", 0, 0, "\033$(B"  ,  4, 0, 0, CT_STD  },

-  { XlcGR,      2, "JISX0208.1983-0:GR", 0, 0, "\033$)B"  ,  4, 0, 0, CT_STD  },

-  { XlcGL,      2, "JISX0212.1990-0:GL", 0, 0, "\033$(D"  ,  4, 0, 0, CT_STD  },

-  { XlcGR,      2, "JISX0212.1990-0:GR", 0, 0, "\033$)D"  ,  4, 0, 0, CT_STD  },

-  { XlcUnknown, 0, "Ignore-Ext-Status?", 0, 0, "\033#"    ,  2, 0, 0, CT_VER  },

-  { XlcUnknown, 0, "NonStd-?-OctetChar", 0, 0, "\033%/0"  ,  4, 0, 0, CT_NSTD },

-  { XlcUnknown, 1, "NonStd-1-OctetChar", 0, 0, "\033%/1"  ,  4, 0, 0, CT_NSTD },

-  { XlcUnknown, 2, "NonStd-2-OctetChar", 0, 0, "\033%/2"  ,  4, 0, 0, CT_NSTD },

-  { XlcUnknown, 3, "NonStd-3-OctetChar", 0, 0, "\033%/3"  ,  4, 0, 0, CT_NSTD },

-  { XlcUnknown, 4, "NonStd-4-OctetChar", 0, 0, "\033%/4"  ,  4, 0, 0, CT_NSTD },

-  { XlcUnknown, 0, "Extension-2"       , 0, 0, "\033%/"   ,  3, 0, 0, CT_EXT2 },

-  { XlcUnknown, 0, "Extension-0"       , 0, 0, "\033"     ,  1, 0, 0, CT_EXT0 },

-  { XlcUnknown, 0, "Begin-L-to-R-Text",  0, 0, "\2331]"   ,  3, 0, 0, CT_DIR  },

-  { XlcUnknown, 0, "Begin-R-to-L-Text",  0, 0, "\2332]"   ,  3, 0, 0, CT_DIR  },

-  { XlcUnknown, 0, "End-Of-String",      0, 0, "\233]"    ,  2, 0, 0, CT_DIR  },

-  { XlcUnknown, 0, "Extension-1"       , 0, 0, "\233"     ,  1, 0, 0, CT_EXT1 },

-};

-

-/* Note on above table:  euc_ctstombs() and euc_ctstowcs() parser depends on

- * certain table entries occuring in decreasing string length--

- *   1.  CT_EXT2 and CT_EXT0 entries must occur after CT_NSTD entries.

- *   2.  CT_DIR and CT_EXT1 entries must occur after CT_DIR entries.

- */

-

-static CTData ctd_endp = ctdata + ((sizeof(ctdata) / sizeof(CTDataRec))) - 1;

-static CTData ctdptr[sizeof(ctdata) / sizeof(CTDataRec)];

-

-#define Ascii   0

-#define Kanji   1

-#define Kana    2

-#define Userdef 3

-

-/*

- * initCTptr(): Set ctdptr[] to point at ctdata[], indexed by codeset_num.

- */

-static void

-initCTptr(

-    XLCd lcd)

-{

-    int num_codesets = XLC_GENERIC(lcd, codeset_num);

-    int num_charsets;

-    int i, j;

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-    CodeSet codeset;

-    XlcCharSet charset;

-    CTData ctdp = ctdata;

-

-    ctdptr[Ascii] = &ctdata[0];		/* failsafe */

-

-    for (i = 0; i < num_codesets; i++) {

-

-	codeset = codesets[i];

-	num_charsets = codeset->num_charsets;

-

-	for (j = 0; j < num_charsets; j++) {

-

-	    charset = codeset->charset_list[j];

-

-	    for (ctdp = ctdata; ctdp <= ctd_endp; ctdp++)

-

-		if (! strcmp(ctdp->name, charset->name)) {

-

-		    ctdptr[codeset->cs_num] = ctdp;

-

-		    ctdptr[codeset->cs_num]->wc_encoding = codeset->wc_encoding;

-

-		    ctdptr[codeset->cs_num]->set_size =

-		      charset->set_size;

-

-		    ctdptr[codeset->cs_num]->min_ch =

-		      charset->set_size == 94 &&

-		      (ctdptr[codeset->cs_num]->length > 1 ||

-		      ctdptr[codeset->cs_num]->side == XlcGR) ? 0x21 : 0x20;

-

-		    if (codeset->parse_info) {

-			ctdptr[codeset->cs_num]->sshift =

-			  *codeset->parse_info->encoding;

-		    }

-

-		    break;

-		}

-	}

-    }

-}

-

-

-#define SKIP_I(str)     while (*(str) >= 0x20 && *(str) <=  0x2f) (str)++;

-#define SKIP_P(str)     while (*(str) >= 0x30 && *(str) <=  0x3f) (str)++;

-

-static int

-euc_ctstowcs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-    Ulong wc_shift_bits = XLC_GENERIC(lcd, wc_shift_bits);

-    const char *inbufptr = *from;

-    const char *inbuf_base;

-    wchar_t *outbufptr = (wchar_t *) *to;

-    wchar_t *outbuf_base = outbufptr;

-    int clen, length;

-    int unconv_num = 0;

-    unsigned int ct_seglen = 0;

-    Uchar ct_type = 0;

-    int shift_mult;

-    wchar_t wc_tmp;

-    wchar_t wch;

-    Ulong wc_encoding;

-    CTData ctdp = ctdata;

-    CTData GL_ctdp = ctdp;	/* GL ctdp save */

-    CTData GR_ctdp = ctdp;	/* GR ctdp save */

-    Bool save_outbuf = True;

-    /* If outbufptr is NULL, doen't save output, but just counts

-       a length to hold the output */

-    if (outbufptr == NULL) save_outbuf = False;

-

-    for (length = ctdata[Ascii].length; *from_left > 0; (*from_left) -= length)

-    {

-	ct_type = CT_STD;

-	/* change GL/GR charset */

-	if(ctdp->side == XlcGR && isleftside(*inbufptr)){

-	    /* select GL side */

-	    ctdp = GL_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){

-	    /* select GR side */

-	    ctdp = GR_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}

-	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {

-	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {

-

-		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))

-		{

-		    inbufptr += ctdp->ct_encoding_len;

-		    (*from_left) -= ctdp->ct_encoding_len;

-		    if (ctdp->length) {

-			length = ctdp->length;

-			if( *from_left < length ) {

-			    *to = (XPointer)outbufptr;

-			    *to_left -= outbufptr - outbuf_base;

-			    return( unconv_num + *from_left );

-			}

-		    }

-		    ct_type = ctdp->ct_type;

-		    if(ctdp->side == XlcGL){

-			GL_ctdp = ctdp; /* save GL ctdp */

-		    }else{

-			GR_ctdp = ctdp; /* save GR ctdp */

-		    }

-		    break;

-		}

-	    }

-	    if (ctdp > ctd_endp) 	/* failed to match CT sequence */

-		unconv_num++;

-	}

-

-/* The following code insures that non-standard encodings, direction, extension,

- * and version strings are ignored; subject to change in future.

- */

-	switch (ct_type) {

-	case CT_STD:

-	    break;

-	case CT_EXT2:

-	    inbufptr++;

-	    (*from_left)--;

-	case CT_NSTD:

-	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;

-	    inbufptr += ct_seglen;

-	    (*from_left) -= ct_seglen;

-	    continue;

-	case CT_EXT0:

-	    inbuf_base = inbufptr;

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    *(from_left) -= ct_seglen;

-	    continue;

-	case CT_EXT1:

-	    inbuf_base = inbufptr;

-	    SKIP_P(inbufptr);

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    *(from_left) -= ct_seglen;

-	    continue;

-	case CT_DIR:

-	    continue;

-	case CT_VER:

-	    inbufptr += 2;

-	    *(from_left) -= 2;

-	    continue;

-	}

-

-	wc_encoding = (ctdp == ctdptr[Kana] && isleftside(*inbufptr)) ?

-	    ctdptr[Ascii]->wc_encoding: ctdp->wc_encoding;

-

-	shift_mult = length - 1;

-	wch = (wchar_t)0;

-	clen = length;

-

-	do {

-	    wc_tmp = BIT8OFF(*inbufptr++) << (wc_shift_bits * shift_mult);

-	    wch |= wc_tmp;

-	    shift_mult--;

-	} while (--clen);

-

-	if (save_outbuf == True)

-	    *outbufptr++ = wch | wc_encoding;

-	if (--*to_left == 0 && *from_left != length) {

-	    *to = (XPointer)outbufptr;

-	    unconv_num = *from_left;

-	    return unconv_num;

-	}

-    }

-

-    *to = (XPointer)outbufptr;

-

-    return unconv_num;

-

-}

-

-

-#define byte1			(length == codeset->length - 1)

-#define byte2			(byte1 == 0)

-#define kanji			(codeset->cs_num == 1)

-#define kana			(codeset->cs_num == 2)

-#define userdef			(codeset->cs_num == 3)

-

-static int

-euc_wcstocts(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    int ct_len = *to_left;

-    const wchar_t *inbufptr = (const wchar_t *) *from;

-    char *ctptr = *to;

-    XPointer ct_base = ctptr;

-    wchar_t  wch;

-    int length;

-    int unconv_num = 0;

-    Uchar tmp;

-    Uchar t1 = 0;

-    int num_conv;

-

-    StateRec ct_state;

-    XLCd lcd = (XLCd)conv->state;

-    CTData charset;

-    CodeSet codeset;

-    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);

-

-/* Initial State: */

-    ct_state.GL_charset = ctdptr[0]; /* Codeset 0 */

-    ct_state.GR_charset = NULL;

-

-    if (*from_left > *to_left)

-	*from_left = *to_left;

-

-    for (; *from_left > 0 ; (*from_left)-- ) {

-

-	wch = *inbufptr++;

-

-	if (!(codeset = wc_codeset(lcd, wch))) {

-	    unconv_num++;

-	    (*from_left)--;

-	    continue;

-	}

-

-	charset = ctdptr[codeset->cs_num];

-

-	length = codeset->length;

-	wch ^= (wchar_t)codeset->wc_encoding;

-

-	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||

-	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {

-

-	    ct_len -= ctdptr[codeset->cs_num]->ct_encoding_len;

-

-	    if (ct_len < 0) {

-		unconv_num++;

-		break;

-	    }

-

-	    if (ctptr) {

-		strcpy(ctptr, ctdptr[codeset->cs_num]->ct_encoding);

-		ctptr += ctdptr[codeset->cs_num]->ct_encoding_len;

-	    }

-	}

-

-	if (charset->side == XlcGR) {

-	    ct_state.GR_charset = charset;

-	    ct_state.GL_charset = NULL;

-	} else if (charset->side == XlcGL) {

-	    ct_state.GL_charset = charset;

-	    ct_state.GR_charset = NULL;

-	}

-

-	do {

-

-	    length--;

-	    tmp = wch>>(wchar_t)( (Ulong)length * wc_shift);

-

-	    if (kana) {

-		if (BADCHAR(charset->min_ch, (char)tmp)) {

-		    unconv_num++;

-		    break;

-		}

-		*ctptr++ = (char)BIT8ON(tmp);

-	    }

-

-	    else if (byte1 && (kanji || userdef))

-		t1 = tmp;

-

-	    else if (byte2 && (kanji || userdef)) {

-		if (BADCHAR(charset->min_ch, (char)t1) ||

-		  BADCHAR(charset->min_ch, (char)tmp)) {

-		    unconv_num++;

-		    break;

-		}

-		if (charset->side == XlcGR) {

-		    *ctptr++ = (char)BIT8ON(t1);

-		    *ctptr++ = (char)BIT8ON(tmp);

-		} else {

-		    *ctptr++ = (char)BIT8OFF(t1);

-		    *ctptr++ = (char)BIT8OFF(tmp);

-		}

-	    }

-

-	    else {

-		if (BADCHAR(charset->min_ch, (char)tmp)) {

-		    unconv_num++;

-		    break;

-		}

-		*ctptr++ = (char)tmp;

-	    }

-

-

-	} while (length);

-

-    }	/* end for */

-

-    *to = (XPointer)ctptr;

-

-    if ((num_conv = (int)(ctptr - ct_base)) > 0)

-	(*to_left) -= num_conv;

-

-    return unconv_num;

-}

-#undef byte1

-#undef byte2

-#undef kana

-#undef kanji

-#undef userdef

-

-

-#define byte1	(ctdp->length == clen)

-#define kana    (ctdp == ctdptr[Kana] && isrightside(*inbufptr))

-/* #define kanji   (ctdp == ctdptr[Kanji]) */

-#define kanji   (strstr(ctdp->name, "JISX0208"))

-#define userdef (ctdp == ctdptr[Userdef])

-

-static int

-euc_ctstombs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    char *inbufptr = *from;

-    XPointer outbufptr = *to;

-    const char *inbuf_base;

-    XPointer outbuf_base = outbufptr;

-    int clen, length;

-    int unconv_num = 0;

-    unsigned int ct_seglen = 0;

-    Uchar ct_type = 0;

-    CTData ctdp = &ctdata[0];	/* default */

-    CTData GL_ctdp = ctdp;	/* GL ctdp save */

-    CTData GR_ctdp = ctdp;	/* GR ctdp save */

-    Bool save_outbuf = True;

-    /* If outbufptr is NULL, doen't save output, but just counts

-       a length to hold the output */

-    if (outbufptr == NULL) save_outbuf = False;

-

-    for (length = ctdata[Ascii].length; *from_left > 0; (*from_left) -= length)

-    {

-	ct_type = CT_STD;

-	/* change GL/GR charset */

-	if(ctdp->side == XlcGR && isleftside(*inbufptr)){

-	    /* select GL side */

-	    ctdp = GL_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){

-	    /* select GR side */

-	    ctdp = GR_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}

-	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {

-

-	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {

-

-		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))

-		{

-		    inbufptr += ctdp->ct_encoding_len;

-		    (*from_left) -= ctdp->ct_encoding_len;

-		    if (ctdp->length) {

-			length = ctdp->length;

-			if( *from_left < length ) {

-			    *to = (XPointer)outbufptr;

-			    *to_left -= outbufptr - outbuf_base;

-			    return( unconv_num + *from_left );

-			}

-		    }

-		    ct_type = ctdp->ct_type;

-		    if(ctdp->side == XlcGL){

-			GL_ctdp = ctdp; /* save GL ctdp */

-		    }else{

-			GR_ctdp = ctdp; /* save GR ctdp */

-		    }

-		    break;

-		}

-	    }

-	    if (ctdp > ctd_endp) 	/* failed to match CT sequence */

-		unconv_num++;

-	}

-

-/* The following code insures that non-standard encodings, direction, extension,

- * and version strings are ignored; subject to change in future.

- */

-	switch (ct_type) {

-	case CT_STD:

-	    break;

-	case CT_EXT2:

-	    inbufptr++;

-	    (*from_left)--;

-	case CT_NSTD:

-	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;

-	    inbufptr += ct_seglen;

-	    (*from_left) -= ct_seglen;

-	    continue;

-	case CT_EXT0:

-	    inbuf_base = inbufptr;

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    *(from_left) -= ct_seglen;

-	    continue;

-	case CT_EXT1:

-	    inbuf_base = inbufptr;

-	    SKIP_P(inbufptr);

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    *(from_left) -= ct_seglen;

-	    continue;

-	case CT_DIR:

-	    continue;

-	case CT_VER:

-	    inbufptr += 2;

-	    *(from_left) -= 2;

-	    continue;

-	}

-

-	clen = length;

-	do {

-

-	    if (byte1) {

-		if (kanji) {

-		    /* FIXME: assignment of read-only location */

-		    *inbufptr = BIT8ON(*inbufptr);

-		    *(inbufptr+1) = BIT8ON(*(inbufptr+1));

-		}

-		else if (kana || userdef) {

-		    if (save_outbuf == True) {

-			*outbufptr++ = ctdp->sshift;

-		    }

-		    (*to_left)--;

-		}

-	    }

-	    if (save_outbuf == True) {

-		*outbufptr++ = *inbufptr;

-	    }

-	    (*to_left)--;

-	    inbufptr++;

-

-	    if (*to_left == 0 && *from_left != length) {

-		*to = (XPointer)outbufptr;

-		unconv_num = *from_left;

-		return unconv_num;

-	    }

-	} while (--clen);

-    }

-

-    *to = outbufptr;

-

-    return unconv_num;

-

-}

-#undef byte1

-#undef kana

-#undef kanji

-#undef userdef

-

-

-static int

-euc_mbstocts(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    int ct_len = *to_left;

-    int cs_num;

-    int clen, length = 0;

-    int unconv_num = 0;

-    int num_conv;

-    const char *inbufptr = *from;

-    char *ctptr = *to;

-    XPointer ct_base = ctptr;

-

-    StateRec ct_state;

-    CTData charset;

-    XLCd lcd = (XLCd) conv->state;

-    int codeset_num = XLC_GENERIC(lcd, codeset_num);

-

-/* Initial State: */

-    ct_state.GL_charset = NULL;

-    ct_state.GR_charset = NULL;

-

-    if (*from_left > *to_left)

-        *from_left = *to_left;

-

-    for (;*from_left > 0; (*from_left) -= length) {

-

-	if (isleftside(*inbufptr)) {		/* 7-bit (CS0) */

-	    if (ASCII_CODESET >= codeset_num) {

-	      	unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Ascii;

-	    charset = ctdptr[Ascii];

-	}

-	else if ((Uchar)*inbufptr == SS2) {	/* Kana */

-	    if (KANA_CODESET >= codeset_num) {

-	      	unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Kana;

-	    charset = ctdptr[Kana];

-	    inbufptr++;

-	    (*from_left)--;

-	}

-	else if ((Uchar)*inbufptr == SS3) {	/* Userdef */

-	    if (USERDEF_CODESET >= codeset_num) {

-	      	unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Userdef;

-	    charset = ctdptr[Userdef];

-	    inbufptr++;

-	    (*from_left)--;

-	}

-	else {

-	    if (KANJI_CODESET >= codeset_num) {

-	      	unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Kanji;

-	    charset = ctdptr[Kanji];

-	}

-

-	length = charset->length;

-

-	if (BADCHAR(charset->min_ch, *inbufptr))

-            continue;

-

-	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||

-	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {

-

-	    ct_len -= ctdptr[cs_num]->ct_encoding_len;

-	    if (ct_len < 0) {

-		unconv_num++;

-		break;

-	    }

-

-	    if (ctptr) {

-		strcpy(ctptr, ctdptr[cs_num]->ct_encoding);

-		ctptr += ctdptr[cs_num]->ct_encoding_len;

-	    }

-	}

-

-	if (charset->side == XlcGR) {

-	    ct_state.GR_charset = charset;

-	    ct_state.GL_charset = NULL;

-	} else if (charset->side == XlcGL) {

-	    ct_state.GL_charset = charset;

-	    ct_state.GR_charset = NULL;

-	}

-

-	clen = length;

-

-	do {

-	    *ctptr++ = charset == ct_state.GR_charset ?

-		BIT8ON(*inbufptr++) : BIT8OFF(*inbufptr++);

-	} while (--clen);

-    }

-

-    *to = (XPointer)ctptr;

-

-    if ((num_conv = (int)(ctptr - ct_base)) > 0)

-	(*to_left) -= num_conv;

-    return unconv_num;

-

-}

-

-

-static void

-close_converter(

-    XlcConv conv)

-{

-	Xfree((char *) conv);

-}

-

-enum { MBSTOCS, WCSTOCS, MBTOCS, CSTOMBS, CSTOWCS, MBSTOWCS, WCSTOMBS,

-       CTSTOWCS, CTSTOMBS, WCSTOCTS, MBSTOCTS };

-

-static XlcConvMethodsRec conv_methods[] = {

-    {close_converter, euc_mbstocs,  NULL },

-    {close_converter, euc_wcstocs,  NULL },

-    {close_converter, euc_mbtocs,   NULL },

-    {close_converter, euc_cstombs,  NULL },

-    {close_converter, euc_cstowcs,  NULL },

-    {close_converter, euc_mbstowcs, NULL },

-    {close_converter, euc_wcstombs, NULL },

-    {close_converter, euc_ctstowcs, NULL },

-    {close_converter, euc_ctstombs, NULL },

-    {close_converter, euc_wcstocts, NULL },

-    {close_converter, euc_mbstocts, NULL },

-};

-

-

-static XlcConv

-open_mbstocs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBSTOCS]);

-}

-

-static XlcConv

-open_wcstocs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[WCSTOCS]);

-}

-

-static XlcConv

-open_mbtocs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBTOCS]);

-}

-

-static XlcConv

-open_cstombs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CSTOMBS]);

-}

-

-static XlcConv

-open_cstowcs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CSTOWCS]);

-}

-

-static XlcConv

-open_mbstowcs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBSTOWCS]);

-}

-

-static XlcConv

-open_wcstombs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[WCSTOMBS]);

-}

-

-static XlcConv

-open_ctstowcs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CTSTOWCS]);

-}

-

-static XlcConv

-open_ctstombs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CTSTOMBS]);

-}

-

-static XlcConv

-open_wcstocts(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[WCSTOCTS]);

-}

-

-static XlcConv

-open_mbstocts(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBSTOCTS]);

-}

-

-XLCd

-_XlcEucLoader(

-    const char *name)

-{

-    XLCd lcd;

-

-    lcd = _XlcCreateLC(name, _XlcGenericMethods);

-    if (lcd == NULL)

-	return lcd;

-

-    if (!XLC_PUBLIC_PART(lcd)->codeset ||

-	(_XlcNCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "euc", 3))) {

-	_XlcDestroyLC(lcd);

-	return (XLCd) NULL;

-    }

-

-    initCTptr(lcd);

-

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_mbstocs);

-    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstocs);

-    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_cstombs);

-    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_cstowcs);

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_mbtocs);

-

-#ifndef FORCE_INDIRECT_CONVERTER

-    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNMultiByte, open_ctstombs);

-    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNWideChar, open_ctstowcs);

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCompoundText, open_mbstocts);

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_mbstowcs);

-    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCompoundText, open_wcstocts);

-    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_wcstombs);

-#endif

-

-    _XlcAddUtf8Converters(lcd);

-

-    return lcd;

-}

-

-#else

-typedef int dummy;

-#endif /* X_LOCALE */

+/******************************************************************
+
+        Copyright 1992, 1993 by FUJITSU LIMITED
+        Copyright 1993 by Fujitsu Open Systems Solutions, Inc.
+
+Permission to use, copy, modify, distribute and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear
+in supporting documentation, and that the name of FUJITSU LIMITED and
+Fujitsu Open Systems Solutions, Inc. not be used in advertising or
+publicity pertaining to distribution of the software without specific,
+written prior permission.
+FUJITSU LIMITED and Fujitsu Open Systems Solutions, Inc. makes no
+representations about the suitability of this software for any purpose.
+It is provided "as is" without express or implied warranty.
+
+FUJITSU LIMITED AND FUJITSU OPEN SYSTEMS SOLUTIONS, INC. DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL FUJITSU OPEN SYSTEMS
+SOLUTIONS, INC. AND FUJITSU LIMITED BE LIABLE FOR ANY SPECIAL, INDIRECT
+OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+OF THIS SOFTWARE.
+
+    Authors: Shigeru Yamada 		(yamada@ossi.com)
+             Jeffrey Bloomfield		(jeffb@ossi.com)
+             Yoshiyuki Segawa		(segawa@ossi.com)
+
+*****************************************************************/
+
+/*
+ * An EUC locale.
+ * Supports: all locales with codeset eucJP, eucKR, eucCN, eucTW.
+ * How: Provides converters for euc*.
+ * Platforms: Only those defining X_LOCALE (only Lynx, Linux-libc5, OS/2).
+ */
+
+#ifdef X_LOCALE
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XlcGeneric.h"
+
+#include <ctype.h>
+#ifdef WIN32
+#define isascii __isascii
+#endif
+
+#define CS0     codesets[0]             /* Codeset 0 - 7-bit ASCII      */
+#define CS1     codesets[1]             /* Codeset 1 - Kanji            */
+#define CS2     codesets[2]             /* Codeset 2 - Half-Kana        */
+#define CS3     codesets[3]             /* Codeset 3 - User defined     */
+
+#define SS2	0x8e	/* Single-shift char: CS2 */
+#define SS3	0x8f    /* Single-shift char: CS3 */
+
+#define ASCII_CODESET   0
+#define KANJI_CODESET   1
+#define KANA_CODESET    2
+#define USERDEF_CODESET 3
+#define MAX_CODESETS
+
+#define GR	0x80	/* begins right-side (non-ascii) region */
+#define GL	0x7f    /* ends left-side (ascii) region        */
+
+#define isleftside(c)	(((c) & GR) ? 0 : 1)
+#define isrightside(c)	(!isleftside(c))
+
+#define BIT8OFF(c)	((c) & GL)
+#define BIT8ON(c)	((c) | GR)
+
+typedef unsigned char   Uchar;
+typedef unsigned long   Ulong;
+typedef unsigned int	Uint;
+
+static CodeSet GetCodeSetFromCharSet (XLCd lcd, XlcCharSet charset);
+static CodeSet wc_codeset (XLCd lcd, wchar_t wch);
+
+#define BADCHAR(min_ch, c)  (BIT8OFF(c) < (char)min_ch && BIT8OFF(c) != 0x0 && \
+			     BIT8OFF(c) != '\t' && BIT8OFF(c) != '\n' && \
+			     BIT8OFF(c) != 0x1b)
+
+/*
+ * Notes:
+ * 1. Defining FORCE_INDIRECT_CONVERTER (see _XlcEucLoader())
+ *    forces indirect (charset) conversions (e.g. wcstocs()<->cstombs()).
+ * 2. Using direct converters (e.g. mbstowcs()) decreases conversion
+ *    times by 20-40% (depends on specific converter used).
+ */
+
+static int
+euc_mbstowcs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+
+    Uchar ch;
+    int chr_len = 0;
+    int sshift =  False;
+    int shift_mult = 0;
+    Uint chrcode;
+
+    Uint wc_encode = 0;
+    Uint wc_tmp = 0;
+
+    int cs0flg = False;
+    int cs1flg = False;
+    int length = 0;
+    int unconv_num = 0;
+
+    Bool new_char;
+
+    const char *inbufptr = *from;
+    wchar_t *outbufptr = (wchar_t *) *to;
+
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+    int codeset_num = XLC_GENERIC(lcd, codeset_num);
+    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);
+
+    for (new_char = True; *from_left > 0 && *to_left > 0;) {
+
+	ch = *inbufptr++;
+
+	if (isleftside(ch)) {				/* CS0 */
+            if (ASCII_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    if( cs0flg == True) {
+		new_char = True;
+		cs0flg = False;
+	    }
+	    length = CS0->length;
+	    *outbufptr++ = (wchar_t)ch;
+	    (*from_left)--;
+	    (*to_left)--;
+	    continue;
+	}
+	else if (ch == SS2) {				/* CS2 */
+	    if (KANA_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    if (sshift == True || cs1flg == True) {
+		cs1flg = False;
+		unconv_num++;
+		continue;
+	    }
+	    length = CS2->length;
+	    wc_encode = CS2->wc_encoding;
+	    chrcode = 0;
+	    sshift = True;
+	    cs0flg = True;
+	    (*from_left)--;
+	    continue;
+	}
+	else if (ch == SS3) {				/* CS3 */
+	    if (USERDEF_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    if (sshift == True || cs1flg == True) {
+		cs1flg = False;
+		unconv_num++;
+		continue;
+	    }
+	    length = CS3->length;
+	    if (*from_left < 1 )
+		unconv_num++;
+	    wc_encode = CS3->wc_encoding;
+	    chrcode = 0;
+	    sshift = True;
+	    cs0flg = True;
+	    (*from_left)--;
+	    continue;
+
+	} else {					/* CS1 */
+	    if (KANJI_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    if (sshift == False) {
+		length = CS1->length;
+		if (*from_left < 1)
+		    unconv_num++;
+		wc_encode = CS1->wc_encoding;
+	    }
+	    chrcode = BIT8OFF(ch);
+	    cs0flg = True;
+	    cs1flg = True;
+	    (*from_left)--;
+	}
+
+	if (new_char) {				/* begin new character */
+	    chr_len = length;
+	    shift_mult = length - 1;
+	    new_char = False;
+	}
+
+	chrcode <<= (wc_shift * shift_mult);
+	shift_mult--;
+	wc_tmp |= chrcode;
+
+	if (--chr_len == 0) {
+	    wc_tmp |= wc_encode;
+	    *outbufptr++ = wc_tmp;
+	    (*to_left)--;
+
+	    new_char = True;
+	    sshift = False;
+	    cs0flg = False;
+	    cs1flg = False;
+	    wc_tmp  = (Uint)0;
+	}
+
+    }	/* end for */
+
+    *to = (XPointer)outbufptr;
+
+    if (cs0flg == True || cs1flg == True)	/* error check on last char */
+	unconv_num++;
+
+    return unconv_num;
+}
+
+
+static int
+euc_wcstombs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    const wchar_t *inbufptr = (const wchar_t *) *from;
+    XPointer outbufptr = *to;
+    wchar_t  wch;
+    int length;
+    Uchar tmp;
+    int unconv_num = 0;
+
+    XLCd lcd = (XLCd)conv->state;
+    CodeSet codeset;
+    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);
+
+    for (; *from_left > 0 && *to_left > 0; (*from_left)-- ) {
+
+	wch = *inbufptr++;
+
+	if (!(codeset = wc_codeset(lcd, wch))) {
+	    unconv_num++;
+	    (*from_left)--;
+	    continue;
+	}
+
+	length = codeset->length;
+	wch ^= (wchar_t)codeset->wc_encoding;
+
+	if (codeset->parse_info) {	/* put out SS2 or SS3 */
+	    if (*to_left < length + 1) {
+	        unconv_num++;
+		break;
+	    }
+	    *outbufptr++ = *codeset->parse_info->encoding;
+	    (*to_left)--;
+        } else {
+	    if (*to_left < length) {
+		unconv_num++;
+		break;
+	    }
+	}
+
+	do {
+	    length--;
+	    tmp = (wch>>(wchar_t)(length * wc_shift));
+
+	    if (codeset->side == XlcGR)
+		tmp = BIT8ON(tmp);
+
+	    *outbufptr++ = (Uchar)tmp;
+	    (*to_left)--;
+	} while (length);
+    }
+
+    *to = (XPointer)outbufptr;
+
+    return unconv_num;
+}
+
+
+static int
+euc_mbtocs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+    XlcCharSet charset;
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+    int codeset_num = XLC_GENERIC(lcd, codeset_num);
+    int length;
+    int unconv_num = 0;
+    int min_ch = 0;
+    const char *src = *from;
+    char *dst = *to;
+
+    if (isleftside(*src)) { 			/* 7-bit (CS0) */
+	if (ASCII_CODESET >= codeset_num)
+	    return -1;
+	charset = *CS0->charset_list;
+    }
+    else if ((Uchar)*src == SS2) {		/* half-kana (CS2) */
+	if (KANA_CODESET >= codeset_num)
+	    return -1;
+	charset = *CS2->charset_list;
+	src++;
+	(*from_left)--;
+    }
+    else if ((Uchar)*src == SS3) {		/* user-def */
+	if (USERDEF_CODESET >= codeset_num)
+	    return -1;
+	charset = *CS3->charset_list;
+	src++;
+	(*from_left)--;
+    }
+    else  { 					/* Kanji (CS1) */
+	if (KANJI_CODESET >= codeset_num)
+	    return -1;
+	charset = *CS1->charset_list;
+    }
+
+    if(*from_left < charset->char_size || *to_left < charset->char_size)
+	return -1;
+
+    min_ch = 0x20;
+    if (charset->set_size == 94)
+	if (charset->char_size > 1 || charset->side == XlcGR)
+	    min_ch = 0x21;
+
+    length = charset->char_size;
+    do {
+	if(BADCHAR(min_ch, *src)) {
+	    unconv_num++;
+	    src++;
+	    break;
+	}
+	switch (charset->side) {
+	    case XlcGL:
+		*dst++ = BIT8OFF(*src++);
+		break;
+	    case XlcGR:
+		*dst++ = BIT8ON(*src++);
+		break;
+	    default:
+		*dst++ = *src++;
+		break;
+	    }
+    } while (--length);
+
+    *to = dst;
+    *from = (XPointer) src;
+    *from_left -= charset->char_size;
+    *to_left -= charset->char_size - length;
+
+    if (num_args > 0)
+	*((XlcCharSet *) args[0]) = charset;
+
+    return unconv_num;
+}
+
+
+static int
+euc_mbstocs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    const char *tmp_from;
+    char *tmp_to;
+    int tmp_from_left, tmp_to_left;
+    XlcCharSet charset, tmp_charset;
+    XPointer tmp_args[1];
+    int unconv_num = 0, ret;
+
+/* Determine the charset of the segment and convert one characater: */
+
+    tmp_args[0] = (XPointer) &charset; /* charset from euc_mbtocs() */
+    while
+      ((ret = euc_mbtocs(conv, from, from_left, to, to_left, tmp_args, 1)) > 0)
+	unconv_num += ret;
+    if ( ret < 0 )
+	return ret;
+
+    tmp_from = *from;
+    tmp_from_left = *from_left;
+    tmp_to_left = *to_left;
+    tmp_to = *to;
+
+/* Convert remainder of the segment: */
+
+    tmp_args[0] = (XPointer) &tmp_charset;
+    while( (ret = euc_mbtocs(conv, (XPointer *) &tmp_from, &tmp_from_left,
+		     (XPointer *) &tmp_to, &tmp_to_left, tmp_args, 1)) >= 0 ) {
+
+	if (ret > 0) {
+	    unconv_num += ret;
+	    continue;
+	}
+
+	if (tmp_charset != charset)  /* quit on end of segment */
+	    break;
+
+	*from = (XPointer) tmp_from;
+	*from_left = tmp_from_left;
+	*to = (XPointer) tmp_to;
+	*to_left = tmp_to_left;
+    }
+
+    if (num_args > 0)
+	*((XlcCharSet *) args[0]) = charset;
+
+    return unconv_num;
+}
+
+
+static int
+euc_wcstocs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+    const wchar_t *wcptr = (const wchar_t *) *from;
+    char *bufptr = (char *) *to;
+    wchar_t wch;
+    char *tmpptr;
+    int length;
+    CodeSet codeset;
+    Ulong wc_encoding;
+    int wcstr_len = *from_left, buf_len = *to_left;
+
+    if (!(codeset = wc_codeset(lcd, *wcptr)))
+	return -1;
+
+    wc_encoding = codeset->wc_encoding;
+
+    if (wcstr_len < buf_len / codeset->length)
+	buf_len = wcstr_len * codeset->length;
+
+    for ( ; wcstr_len > 0 && buf_len > 0; wcptr++, wcstr_len--) {
+	wch = *wcptr;
+
+	if ((wch & XLC_GENERIC(lcd, wc_encode_mask)) != wc_encoding)
+	    break;
+
+	length = codeset->length;
+
+	buf_len -= length;
+	bufptr += length;
+	tmpptr = bufptr - 1;
+
+	while (length--) {
+	    *tmpptr-- = codeset->length == 1 && codeset->side == XlcGR ?
+	      BIT8ON(wch) : BIT8OFF(wch);
+	    wch >>= (wchar_t)XLC_GENERIC(lcd, wc_shift_bits);
+	}
+    }
+
+    if (num_args > 0)
+	*((XlcCharSet *) args[0]) = *codeset->charset_list;
+
+    *from_left -= wcptr - (wchar_t *) *from;
+    *from = (XPointer) wcptr;
+
+    *to_left -= bufptr - *to;
+    *to = bufptr;
+
+    return 0;
+}
+
+
+static int
+euc_cstombs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+    const char *csptr = *from;
+    char *bufptr = *to;
+    int csstr_len = *from_left;
+    int buf_len = *to_left;
+    int length;
+    CodeSet codeset;
+    int cvt_length;
+
+    if (num_args < 1)
+	return -1;
+
+    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))
+	return -1;
+
+    cvt_length = 0;
+    csstr_len /= codeset->length;
+    buf_len /= codeset->length;
+
+    if (codeset->parse_info)
+	csstr_len *= 2;
+
+    if (csstr_len < buf_len)
+	buf_len = csstr_len;
+
+    cvt_length += buf_len * codeset->length;
+
+    if (bufptr) {
+	while (buf_len--) {
+	    if (codeset->parse_info)	/* put out SS2 or SS3 */
+		*bufptr++ = *codeset->parse_info->encoding;
+
+	    length = codeset->length;
+	    while (length--)
+		*bufptr++ = codeset->side == XlcGR ?
+		  BIT8ON(*csptr++) : BIT8OFF(*csptr++);
+	}
+    }
+
+    *from_left -= csptr - *from;
+    *from = (XPointer) csptr;
+    if (bufptr)
+	*to += cvt_length;
+    *to_left -= cvt_length;
+
+    return 0;
+}
+
+
+static int
+euc_cstowcs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+    const char *csptr = *from;
+    wchar_t *bufptr = (wchar_t *) *to;
+    wchar_t *toptr = (wchar_t *) *to;
+    int csstr_len = *from_left;
+    int buf_len = *to_left;
+    wchar_t wch;
+    int length;
+    Ulong wc_shift_bits = XLC_GENERIC(lcd, wc_shift_bits);
+    CodeSet codeset;
+
+    if (num_args < 1)
+	return -1;
+
+    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))
+        return -1;
+
+    csstr_len /= codeset->length;
+    if (csstr_len < buf_len)
+	buf_len = csstr_len;
+    *to_left -= buf_len;
+
+    if (bufptr) {
+
+	toptr += buf_len;
+	*to = (XPointer) toptr;
+
+        while (buf_len--) {
+
+            wch = (wchar_t) BIT8OFF(*csptr);
+            csptr++;
+
+            length = codeset->length - 1;
+            while (length--) {
+                wch = (wch << wc_shift_bits) | BIT8OFF(*csptr);
+                csptr++;
+            }
+            *bufptr++ = wch | codeset->wc_encoding;
+        }
+    }
+    *from_left -= csptr - *from;
+    *from = (XPointer) csptr;
+
+    return 0;
+}
+
+
+static CodeSet
+wc_codeset(
+    XLCd lcd,
+    wchar_t wch)
+{
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+    int end = XLC_GENERIC(lcd, codeset_num);
+    Ulong widech = (Ulong)(wch & XLC_GENERIC(lcd, wc_encode_mask));
+
+    for (; --end >= 0; codesets++)
+	if ( widech == (*codesets)->wc_encoding )
+	    return *codesets;
+
+    return NULL;
+}
+
+
+static CodeSet
+GetCodeSetFromCharSet(
+    XLCd lcd,
+    XlcCharSet charset)
+{
+    CodeSet *codeset = XLC_GENERIC(lcd, codeset_list);
+    XlcCharSet *charset_list;
+    int codeset_num, num_charsets;
+
+    codeset_num = XLC_GENERIC(lcd, codeset_num);
+
+    for ( ; codeset_num-- > 0; codeset++) {
+	num_charsets = (*codeset)->num_charsets;
+	charset_list = (*codeset)->charset_list;
+
+	for ( ; num_charsets-- > 0; charset_list++)
+	    if (*charset_list == charset)
+		return *codeset;
+    }
+
+    return (CodeSet) NULL;
+}
+
+
+static XlcConv
+create_conv(
+    XLCd lcd,
+    XlcConvMethods methods)
+{
+    XlcConv conv;
+
+    conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));
+    if (conv == NULL)
+	return (XlcConv) NULL;
+
+    conv->methods = methods;
+    conv->state = (XPointer) lcd;
+    return conv;
+}
+
+
+/*
+ *    Stripped down Direct CT converters for EUC
+ *
+ */
+
+typedef struct _CTDataRec {
+    int side;
+    int length;
+    char *name;
+    Ulong wc_encoding;
+    char sshift;
+    char *ct_encoding;
+    int ct_encoding_len;
+    int set_size;
+    Uchar min_ch;
+    Uchar ct_type;
+} CTDataRec, *CTData;
+
+typedef struct _StateRec {
+    CTData GL_charset;
+    CTData GR_charset;
+    CTData charset;
+} StateRec, *State;
+
+#define CT_STD  0
+#define CT_NSTD 1
+#define CT_DIR  2
+#define CT_EXT0 3
+#define CT_EXT1 4
+#define CT_EXT2 5
+#define CT_VER  6
+
+static CTDataRec ctdata[] =
+{
+  { XlcGL,      1, "ISO8859-1:GL",       0, 0, "\033(B"   ,  3, 0, 0, CT_STD  },
+  { XlcGR,      1, "ISO8859-1:GR",       0, 0, "\033-A"   ,  3, 0, 0, CT_STD  },
+  { XlcGL,      1, "JISX0201.1976-0:GL", 0, 0, "\033(J"   ,  3, 0, 0, CT_STD  },
+  { XlcGR,      1, "JISX0201.1976-0:GR", 0, 0, "\033)I"   ,  3, 0, 0, CT_STD  },
+  { XlcGL,      2, "JISX0208.1983-0:GL", 0, 0, "\033$(B"  ,  4, 0, 0, CT_STD  },
+  { XlcGR,      2, "JISX0208.1983-0:GR", 0, 0, "\033$)B"  ,  4, 0, 0, CT_STD  },
+  { XlcGL,      2, "JISX0212.1990-0:GL", 0, 0, "\033$(D"  ,  4, 0, 0, CT_STD  },
+  { XlcGR,      2, "JISX0212.1990-0:GR", 0, 0, "\033$)D"  ,  4, 0, 0, CT_STD  },
+  { XlcUnknown, 0, "Ignore-Ext-Status?", 0, 0, "\033#"    ,  2, 0, 0, CT_VER  },
+  { XlcUnknown, 0, "NonStd-?-OctetChar", 0, 0, "\033%/0"  ,  4, 0, 0, CT_NSTD },
+  { XlcUnknown, 1, "NonStd-1-OctetChar", 0, 0, "\033%/1"  ,  4, 0, 0, CT_NSTD },
+  { XlcUnknown, 2, "NonStd-2-OctetChar", 0, 0, "\033%/2"  ,  4, 0, 0, CT_NSTD },
+  { XlcUnknown, 3, "NonStd-3-OctetChar", 0, 0, "\033%/3"  ,  4, 0, 0, CT_NSTD },
+  { XlcUnknown, 4, "NonStd-4-OctetChar", 0, 0, "\033%/4"  ,  4, 0, 0, CT_NSTD },
+  { XlcUnknown, 0, "Extension-2"       , 0, 0, "\033%/"   ,  3, 0, 0, CT_EXT2 },
+  { XlcUnknown, 0, "Extension-0"       , 0, 0, "\033"     ,  1, 0, 0, CT_EXT0 },
+  { XlcUnknown, 0, "Begin-L-to-R-Text",  0, 0, "\2331]"   ,  3, 0, 0, CT_DIR  },
+  { XlcUnknown, 0, "Begin-R-to-L-Text",  0, 0, "\2332]"   ,  3, 0, 0, CT_DIR  },
+  { XlcUnknown, 0, "End-Of-String",      0, 0, "\233]"    ,  2, 0, 0, CT_DIR  },
+  { XlcUnknown, 0, "Extension-1"       , 0, 0, "\233"     ,  1, 0, 0, CT_EXT1 },
+};
+
+/* Note on above table:  euc_ctstombs() and euc_ctstowcs() parser depends on
+ * certain table entries occuring in decreasing string length--
+ *   1.  CT_EXT2 and CT_EXT0 entries must occur after CT_NSTD entries.
+ *   2.  CT_DIR and CT_EXT1 entries must occur after CT_DIR entries.
+ */
+
+static CTData ctd_endp = ctdata + ((sizeof(ctdata) / sizeof(CTDataRec))) - 1;
+static CTData ctdptr[sizeof(ctdata) / sizeof(CTDataRec)];
+
+#define Ascii   0
+#define Kanji   1
+#define Kana    2
+#define Userdef 3
+
+/*
+ * initCTptr(): Set ctdptr[] to point at ctdata[], indexed by codeset_num.
+ */
+static void
+initCTptr(
+    XLCd lcd)
+{
+    int num_codesets = XLC_GENERIC(lcd, codeset_num);
+    int num_charsets;
+    int i, j;
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+    CodeSet codeset;
+    XlcCharSet charset;
+    CTData ctdp = ctdata;
+
+    ctdptr[Ascii] = &ctdata[0];		/* failsafe */
+
+    for (i = 0; i < num_codesets; i++) {
+
+	codeset = codesets[i];
+	num_charsets = codeset->num_charsets;
+
+	for (j = 0; j < num_charsets; j++) {
+
+	    charset = codeset->charset_list[j];
+
+	    for (ctdp = ctdata; ctdp <= ctd_endp; ctdp++)
+
+		if (! strcmp(ctdp->name, charset->name)) {
+
+		    ctdptr[codeset->cs_num] = ctdp;
+
+		    ctdptr[codeset->cs_num]->wc_encoding = codeset->wc_encoding;
+
+		    ctdptr[codeset->cs_num]->set_size =
+		      charset->set_size;
+
+		    ctdptr[codeset->cs_num]->min_ch =
+		      charset->set_size == 94 &&
+		      (ctdptr[codeset->cs_num]->length > 1 ||
+		      ctdptr[codeset->cs_num]->side == XlcGR) ? 0x21 : 0x20;
+
+		    if (codeset->parse_info) {
+			ctdptr[codeset->cs_num]->sshift =
+			  *codeset->parse_info->encoding;
+		    }
+
+		    break;
+		}
+	}
+    }
+}
+
+
+#define SKIP_I(str)     while (*(str) >= 0x20 && *(str) <=  0x2f) (str)++;
+#define SKIP_P(str)     while (*(str) >= 0x30 && *(str) <=  0x3f) (str)++;
+
+static int
+euc_ctstowcs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+    Ulong wc_shift_bits = XLC_GENERIC(lcd, wc_shift_bits);
+    const char *inbufptr = *from;
+    const char *inbuf_base;
+    wchar_t *outbufptr = (wchar_t *) *to;
+    wchar_t *outbuf_base = outbufptr;
+    int clen, length;
+    int unconv_num = 0;
+    unsigned int ct_seglen = 0;
+    Uchar ct_type = 0;
+    int shift_mult;
+    wchar_t wc_tmp;
+    wchar_t wch;
+    Ulong wc_encoding;
+    CTData ctdp = ctdata;
+    CTData GL_ctdp = ctdp;	/* GL ctdp save */
+    CTData GR_ctdp = ctdp;	/* GR ctdp save */
+    Bool save_outbuf = True;
+    /* If outbufptr is NULL, doen't save output, but just counts
+       a length to hold the output */
+    if (outbufptr == NULL) save_outbuf = False;
+
+    for (length = ctdata[Ascii].length; *from_left > 0; (*from_left) -= length)
+    {
+	ct_type = CT_STD;
+	/* change GL/GR charset */
+	if(ctdp->side == XlcGR && isleftside(*inbufptr)){
+	    /* select GL side */
+	    ctdp = GL_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){
+	    /* select GR side */
+	    ctdp = GR_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}
+	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {
+	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {
+
+		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))
+		{
+		    inbufptr += ctdp->ct_encoding_len;
+		    (*from_left) -= ctdp->ct_encoding_len;
+		    if (ctdp->length) {
+			length = ctdp->length;
+			if( *from_left < length ) {
+			    *to = (XPointer)outbufptr;
+			    *to_left -= outbufptr - outbuf_base;
+			    return( unconv_num + *from_left );
+			}
+		    }
+		    ct_type = ctdp->ct_type;
+		    if(ctdp->side == XlcGL){
+			GL_ctdp = ctdp; /* save GL ctdp */
+		    }else{
+			GR_ctdp = ctdp; /* save GR ctdp */
+		    }
+		    break;
+		}
+	    }
+	    if (ctdp > ctd_endp) 	/* failed to match CT sequence */
+		unconv_num++;
+	}
+
+/* The following code insures that non-standard encodings, direction, extension,
+ * and version strings are ignored; subject to change in future.
+ */
+	switch (ct_type) {
+	case CT_STD:
+	    break;
+	case CT_EXT2:
+	    inbufptr++;
+	    (*from_left)--;
+	case CT_NSTD:
+	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;
+	    inbufptr += ct_seglen;
+	    (*from_left) -= ct_seglen;
+	    continue;
+	case CT_EXT0:
+	    inbuf_base = inbufptr;
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    *(from_left) -= ct_seglen;
+	    continue;
+	case CT_EXT1:
+	    inbuf_base = inbufptr;
+	    SKIP_P(inbufptr);
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    *(from_left) -= ct_seglen;
+	    continue;
+	case CT_DIR:
+	    continue;
+	case CT_VER:
+	    inbufptr += 2;
+	    *(from_left) -= 2;
+	    continue;
+	}
+
+	wc_encoding = (ctdp == ctdptr[Kana] && isleftside(*inbufptr)) ?
+	    ctdptr[Ascii]->wc_encoding: ctdp->wc_encoding;
+
+	shift_mult = length - 1;
+	wch = (wchar_t)0;
+	clen = length;
+
+	do {
+	    wc_tmp = BIT8OFF(*inbufptr++) << (wc_shift_bits * shift_mult);
+	    wch |= wc_tmp;
+	    shift_mult--;
+	} while (--clen);
+
+	if (save_outbuf == True)
+	    *outbufptr++ = wch | wc_encoding;
+	if (--*to_left == 0 && *from_left != length) {
+	    *to = (XPointer)outbufptr;
+	    unconv_num = *from_left;
+	    return unconv_num;
+	}
+    }
+
+    *to = (XPointer)outbufptr;
+
+    return unconv_num;
+
+}
+
+
+#define byte1			(length == codeset->length - 1)
+#define byte2			(byte1 == 0)
+#define kanji			(codeset->cs_num == 1)
+#define kana			(codeset->cs_num == 2)
+#define userdef			(codeset->cs_num == 3)
+
+static int
+euc_wcstocts(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    int ct_len = *to_left;
+    const wchar_t *inbufptr = (const wchar_t *) *from;
+    char *ctptr = *to;
+    XPointer ct_base = ctptr;
+    wchar_t  wch;
+    int length;
+    int unconv_num = 0;
+    Uchar tmp;
+    Uchar t1 = 0;
+    int num_conv;
+
+    StateRec ct_state;
+    XLCd lcd = (XLCd)conv->state;
+    CTData charset;
+    CodeSet codeset;
+    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);
+
+/* Initial State: */
+    ct_state.GL_charset = ctdptr[0]; /* Codeset 0 */
+    ct_state.GR_charset = NULL;
+
+    if (*from_left > *to_left)
+	*from_left = *to_left;
+
+    for (; *from_left > 0 ; (*from_left)-- ) {
+
+	wch = *inbufptr++;
+
+	if (!(codeset = wc_codeset(lcd, wch))) {
+	    unconv_num++;
+	    (*from_left)--;
+	    continue;
+	}
+
+	charset = ctdptr[codeset->cs_num];
+
+	length = codeset->length;
+	wch ^= (wchar_t)codeset->wc_encoding;
+
+	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||
+	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {
+
+	    ct_len -= ctdptr[codeset->cs_num]->ct_encoding_len;
+
+	    if (ct_len < 0) {
+		unconv_num++;
+		break;
+	    }
+
+	    if (ctptr) {
+		strcpy(ctptr, ctdptr[codeset->cs_num]->ct_encoding);
+		ctptr += ctdptr[codeset->cs_num]->ct_encoding_len;
+	    }
+	}
+
+	if (charset->side == XlcGR) {
+	    ct_state.GR_charset = charset;
+	    ct_state.GL_charset = NULL;
+	} else if (charset->side == XlcGL) {
+	    ct_state.GL_charset = charset;
+	    ct_state.GR_charset = NULL;
+	}
+
+	do {
+
+	    length--;
+	    tmp = wch>>(wchar_t)( (Ulong)length * wc_shift);
+
+	    if (kana) {
+		if (BADCHAR(charset->min_ch, (char)tmp)) {
+		    unconv_num++;
+		    break;
+		}
+		*ctptr++ = (char)BIT8ON(tmp);
+	    }
+
+	    else if (byte1 && (kanji || userdef))
+		t1 = tmp;
+
+	    else if (byte2 && (kanji || userdef)) {
+		if (BADCHAR(charset->min_ch, (char)t1) ||
+		  BADCHAR(charset->min_ch, (char)tmp)) {
+		    unconv_num++;
+		    break;
+		}
+		if (charset->side == XlcGR) {
+		    *ctptr++ = (char)BIT8ON(t1);
+		    *ctptr++ = (char)BIT8ON(tmp);
+		} else {
+		    *ctptr++ = (char)BIT8OFF(t1);
+		    *ctptr++ = (char)BIT8OFF(tmp);
+		}
+	    }
+
+	    else {
+		if (BADCHAR(charset->min_ch, (char)tmp)) {
+		    unconv_num++;
+		    break;
+		}
+		*ctptr++ = (char)tmp;
+	    }
+
+
+	} while (length);
+
+    }	/* end for */
+
+    *to = (XPointer)ctptr;
+
+    if ((num_conv = (int)(ctptr - ct_base)) > 0)
+	(*to_left) -= num_conv;
+
+    return unconv_num;
+}
+#undef byte1
+#undef byte2
+#undef kana
+#undef kanji
+#undef userdef
+
+
+#define byte1	(ctdp->length == clen)
+#define kana    (ctdp == ctdptr[Kana] && isrightside(*inbufptr))
+/* #define kanji   (ctdp == ctdptr[Kanji]) */
+#define kanji   (strstr(ctdp->name, "JISX0208"))
+#define userdef (ctdp == ctdptr[Userdef])
+
+static int
+euc_ctstombs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    char *inbufptr = *from;
+    XPointer outbufptr = *to;
+    const char *inbuf_base;
+    XPointer outbuf_base = outbufptr;
+    int clen, length;
+    int unconv_num = 0;
+    unsigned int ct_seglen = 0;
+    Uchar ct_type = 0;
+    CTData ctdp = &ctdata[0];	/* default */
+    CTData GL_ctdp = ctdp;	/* GL ctdp save */
+    CTData GR_ctdp = ctdp;	/* GR ctdp save */
+    Bool save_outbuf = True;
+    /* If outbufptr is NULL, doen't save output, but just counts
+       a length to hold the output */
+    if (outbufptr == NULL) save_outbuf = False;
+
+    for (length = ctdata[Ascii].length; *from_left > 0; (*from_left) -= length)
+    {
+	ct_type = CT_STD;
+	/* change GL/GR charset */
+	if(ctdp->side == XlcGR && isleftside(*inbufptr)){
+	    /* select GL side */
+	    ctdp = GL_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){
+	    /* select GR side */
+	    ctdp = GR_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}
+	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {
+
+	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {
+
+		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))
+		{
+		    inbufptr += ctdp->ct_encoding_len;
+		    (*from_left) -= ctdp->ct_encoding_len;
+		    if (ctdp->length) {
+			length = ctdp->length;
+			if( *from_left < length ) {
+			    *to = (XPointer)outbufptr;
+			    *to_left -= outbufptr - outbuf_base;
+			    return( unconv_num + *from_left );
+			}
+		    }
+		    ct_type = ctdp->ct_type;
+		    if(ctdp->side == XlcGL){
+			GL_ctdp = ctdp; /* save GL ctdp */
+		    }else{
+			GR_ctdp = ctdp; /* save GR ctdp */
+		    }
+		    break;
+		}
+	    }
+	    if (ctdp > ctd_endp) 	/* failed to match CT sequence */
+		unconv_num++;
+	}
+
+/* The following code insures that non-standard encodings, direction, extension,
+ * and version strings are ignored; subject to change in future.
+ */
+	switch (ct_type) {
+	case CT_STD:
+	    break;
+	case CT_EXT2:
+	    inbufptr++;
+	    (*from_left)--;
+	case CT_NSTD:
+	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;
+	    inbufptr += ct_seglen;
+	    (*from_left) -= ct_seglen;
+	    continue;
+	case CT_EXT0:
+	    inbuf_base = inbufptr;
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    *(from_left) -= ct_seglen;
+	    continue;
+	case CT_EXT1:
+	    inbuf_base = inbufptr;
+	    SKIP_P(inbufptr);
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    *(from_left) -= ct_seglen;
+	    continue;
+	case CT_DIR:
+	    continue;
+	case CT_VER:
+	    inbufptr += 2;
+	    *(from_left) -= 2;
+	    continue;
+	}
+
+	clen = length;
+	do {
+
+	    if (byte1) {
+		if (kanji) {
+		    /* FIXME: assignment of read-only location */
+		    *inbufptr = BIT8ON(*inbufptr);
+		    *(inbufptr+1) = BIT8ON(*(inbufptr+1));
+		}
+		else if (kana || userdef) {
+		    if (save_outbuf == True) {
+			*outbufptr++ = ctdp->sshift;
+		    }
+		    (*to_left)--;
+		}
+	    }
+	    if (save_outbuf == True) {
+		*outbufptr++ = *inbufptr;
+	    }
+	    (*to_left)--;
+	    inbufptr++;
+
+	    if (*to_left == 0 && *from_left != length) {
+		*to = (XPointer)outbufptr;
+		unconv_num = *from_left;
+		return unconv_num;
+	    }
+	} while (--clen);
+    }
+
+    *to = outbufptr;
+
+    return unconv_num;
+
+}
+#undef byte1
+#undef kana
+#undef kanji
+#undef userdef
+
+
+static int
+euc_mbstocts(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    int ct_len = *to_left;
+    int cs_num;
+    int clen, length = 0;
+    int unconv_num = 0;
+    int num_conv;
+    const char *inbufptr = *from;
+    char *ctptr = *to;
+    XPointer ct_base = ctptr;
+
+    StateRec ct_state;
+    CTData charset;
+    XLCd lcd = (XLCd) conv->state;
+    int codeset_num = XLC_GENERIC(lcd, codeset_num);
+
+/* Initial State: */
+    ct_state.GL_charset = NULL;
+    ct_state.GR_charset = NULL;
+
+    if (*from_left > *to_left)
+        *from_left = *to_left;
+
+    for (;*from_left > 0; (*from_left) -= length) {
+
+	if (isleftside(*inbufptr)) {		/* 7-bit (CS0) */
+	    if (ASCII_CODESET >= codeset_num) {
+	      	unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Ascii;
+	    charset = ctdptr[Ascii];
+	}
+	else if ((Uchar)*inbufptr == SS2) {	/* Kana */
+	    if (KANA_CODESET >= codeset_num) {
+	      	unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Kana;
+	    charset = ctdptr[Kana];
+	    inbufptr++;
+	    (*from_left)--;
+	}
+	else if ((Uchar)*inbufptr == SS3) {	/* Userdef */
+	    if (USERDEF_CODESET >= codeset_num) {
+	      	unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Userdef;
+	    charset = ctdptr[Userdef];
+	    inbufptr++;
+	    (*from_left)--;
+	}
+	else {
+	    if (KANJI_CODESET >= codeset_num) {
+	      	unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Kanji;
+	    charset = ctdptr[Kanji];
+	}
+
+	length = charset->length;
+
+	if (BADCHAR(charset->min_ch, *inbufptr))
+            continue;
+
+	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||
+	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {
+
+	    ct_len -= ctdptr[cs_num]->ct_encoding_len;
+	    if (ct_len < 0) {
+		unconv_num++;
+		break;
+	    }
+
+	    if (ctptr) {
+		strcpy(ctptr, ctdptr[cs_num]->ct_encoding);
+		ctptr += ctdptr[cs_num]->ct_encoding_len;
+	    }
+	}
+
+	if (charset->side == XlcGR) {
+	    ct_state.GR_charset = charset;
+	    ct_state.GL_charset = NULL;
+	} else if (charset->side == XlcGL) {
+	    ct_state.GL_charset = charset;
+	    ct_state.GR_charset = NULL;
+	}
+
+	clen = length;
+
+	do {
+	    *ctptr++ = charset == ct_state.GR_charset ?
+		BIT8ON(*inbufptr++) : BIT8OFF(*inbufptr++);
+	} while (--clen);
+    }
+
+    *to = (XPointer)ctptr;
+
+    if ((num_conv = (int)(ctptr - ct_base)) > 0)
+	(*to_left) -= num_conv;
+    return unconv_num;
+
+}
+
+
+static void
+close_converter(
+    XlcConv conv)
+{
+	Xfree((char *) conv);
+}
+
+enum { MBSTOCS, WCSTOCS, MBTOCS, CSTOMBS, CSTOWCS, MBSTOWCS, WCSTOMBS,
+       CTSTOWCS, CTSTOMBS, WCSTOCTS, MBSTOCTS };
+
+static XlcConvMethodsRec conv_methods[] = {
+    {close_converter, euc_mbstocs,  NULL },
+    {close_converter, euc_wcstocs,  NULL },
+    {close_converter, euc_mbtocs,   NULL },
+    {close_converter, euc_cstombs,  NULL },
+    {close_converter, euc_cstowcs,  NULL },
+    {close_converter, euc_mbstowcs, NULL },
+    {close_converter, euc_wcstombs, NULL },
+    {close_converter, euc_ctstowcs, NULL },
+    {close_converter, euc_ctstombs, NULL },
+    {close_converter, euc_wcstocts, NULL },
+    {close_converter, euc_mbstocts, NULL },
+};
+
+
+static XlcConv
+open_mbstocs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBSTOCS]);
+}
+
+static XlcConv
+open_wcstocs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[WCSTOCS]);
+}
+
+static XlcConv
+open_mbtocs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBTOCS]);
+}
+
+static XlcConv
+open_cstombs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CSTOMBS]);
+}
+
+static XlcConv
+open_cstowcs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CSTOWCS]);
+}
+
+static XlcConv
+open_mbstowcs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBSTOWCS]);
+}
+
+static XlcConv
+open_wcstombs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[WCSTOMBS]);
+}
+
+static XlcConv
+open_ctstowcs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CTSTOWCS]);
+}
+
+static XlcConv
+open_ctstombs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CTSTOMBS]);
+}
+
+static XlcConv
+open_wcstocts(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[WCSTOCTS]);
+}
+
+static XlcConv
+open_mbstocts(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBSTOCTS]);
+}
+
+XLCd
+_XlcEucLoader(
+    const char *name)
+{
+    XLCd lcd;
+
+    lcd = _XlcCreateLC(name, _XlcGenericMethods);
+    if (lcd == NULL)
+	return lcd;
+
+    if (!XLC_PUBLIC_PART(lcd)->codeset ||
+	(_XlcNCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "euc", 3))) {
+	_XlcDestroyLC(lcd);
+	return (XLCd) NULL;
+    }
+
+    initCTptr(lcd);
+
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_mbstocs);
+    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstocs);
+    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_cstombs);
+    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_cstowcs);
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_mbtocs);
+
+#ifndef FORCE_INDIRECT_CONVERTER
+    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNMultiByte, open_ctstombs);
+    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNWideChar, open_ctstowcs);
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCompoundText, open_mbstocts);
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_mbstowcs);
+    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCompoundText, open_wcstocts);
+    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_wcstombs);
+#endif
+
+    _XlcAddUtf8Converters(lcd);
+
+    return lcd;
+}
+
+#else
+typedef int dummy;
+#endif /* X_LOCALE */
diff --git a/libX11/modules/lc/xlocale/lcSjis.c b/libX11/modules/lc/xlocale/lcSjis.c
index a7a9bbc4f..74dd033ec 100644
--- a/libX11/modules/lc/xlocale/lcSjis.c
+++ b/libX11/modules/lc/xlocale/lcSjis.c
@@ -1,1612 +1,1612 @@
-/****************************************************************

-

-        Copyright 1992, 1993 by FUJITSU LIMITED

-        Copyright 1993 by Fujitsu Open Systems Solutions, Inc.

-	Copyright 1994 by Sony Corporation

-

-Permission to use, copy, modify, distribute and sell this software

-and its documentation for any purpose is hereby granted without fee,

-provided that the above copyright notice appear in all copies and

-that both that copyright notice and this permission notice appear

-in supporting documentation, and that the name of FUJITSU LIMITED,

-Fujitsu Open Systems Solutions, Inc. and Sony Corporation  not be

-used in advertising or publicity pertaining to distribution of the

-software without specific, written prior permission.

-FUJITSU LIMITED, Fujitsu Open Systems Solutions, Inc. and

-Sony Corporation make no representations about the suitability of

-this software for any purpose.  It is provided "as is" without

-express or implied warranty.

-

-FUJITSU LIMITED, FUJITSU OPEN SYSTEMS SOLUTIONS, INC. AND SONY

-CORPORATION DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,

-IN NO EVENT SHALL FUJITSU OPEN SYSTEMS SOLUTIONS, INC., FUJITSU LIMITED

-AND SONY CORPORATION BE LIABLE FOR ANY SPECIAL, INDIRECT OR

-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

-OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE

-OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE

-OR PERFORMANCE OF THIS SOFTWARE.

-

-    Authors: Jeffrey Bloomfield		(jeffb@ossi.com)

-	     Shigeru Yamada		(yamada@ossi.com)

-             Yoshiyuki Segawa		(segawa@ossi.com)

-    Modifier:Makoto Wakamatsu   Sony Corporation

-				makoto@sm.sony.co.jp

-

-*****************************************************************/

-

-/*

- * A Japanese SJIS locale.

- * Supports: all locales with codeset SJIS.

- * How: Provides converters for SJIS.

- * Platforms: Only those defining X_LOCALE (only Lynx, Linux-libc5, OS/2).

- */

-

-#ifdef X_LOCALE

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XlcGeneric.h"

-

-#include <ctype.h>

-#ifdef WIN32

-#define isascii __isascii

-#endif

-

-#define CS0	codesets[0]		/* Codeset 0 - 7-bit ASCII	*/

-#define CS1	codesets[1]		/* Codeset 1 - Kanji		*/

-#define CS2	codesets[2]		/* Codeset 2 - Half-Kana	*/

-#define CS3	codesets[3]		/* Codeset 3 - User defined	*/

-

-#define ascii		(codeset->cs_num == 0)

-#define kanji		(codeset->cs_num == 1)

-#define kana		(codeset->cs_num == 2)

-#define userdef		(codeset->cs_num == 3)

-

-#define	ASCII_CODESET	0

-#define KANJI_CODESET	1

-#define KANA_CODESET	2

-#define USERDEF_CODESET	3

-#define MAX_CODESETS	4

-

-#define GR	0x80	/* begins right-side (non-ascii) region */

-#define GL	0x7f    /* ends left-side (ascii) region        */

-

-#define isleftside(c)	(((c) & GR) ? 0 : 1)

-#define isrightside(c)	(!isleftside(c))

-

-typedef unsigned char   Uchar;

-typedef unsigned long	Ulong;

-typedef unsigned int	Uint;

-

-/* Acceptable range for 2nd byte of SJIS multibyte char */

-#define VALID_MULTIBYTE(c) \

-			((0x40<=((Uchar)c) && ((Uchar)c)<=0x7e) \

-			|| (0x80<=((Uchar)c) && ((Uchar)c)<=0xfc))

-

-#ifndef iskanji

-#define iskanji(c)	((0x81<=((Uchar)c) && ((Uchar)c)<=0x9f) \

-			|| (0xe0<=((Uchar)c) && ((Uchar)c)<=0xef))

-#endif /* !iskanji */

-

-#ifndef iskana

-#define iskana(c)	(0xa1<=((Uchar)c) && ((Uchar)c)<=0xdf)

-#endif /* !iskana */

-

-#define	isuserdef(c)	(0xf0<=((Uchar)c) && ((Uchar)c)<=0xfc)

-

-#define BIT8OFF(c)	((c) & GL)

-#define BIT8ON(c)	((c) | GR)

-

-

-static void jis_to_sjis (Uchar *p1, Uchar *p2);

-static void sjis_to_jis (Uchar *p1, Uchar *p2);

-static CodeSet wc_codeset (XLCd lcd, wchar_t wch);

-

-

-/*

- * Notes:

- * 1.  16-bit widechar format is limited to 14 data bits.  Since the 2nd byte

- *     of SJIS multibyte chars are in the ranges of 0x40 - 7E and 0x80 - 0xFC,

- *     SJIS cannot map directly into 16 bit widechar format within the confines

- *     of a single codeset.  Therefore, for SJIS widechar conversion, SJIS Kanji

- *     is mapped into the JIS codeset.  (The algorithms used in jis_to_sjis()

- *     and sjis_to_jis() are from Ken Lunde (lunde@mv.us.adobe.com) and are in

- *     the public domain.)

- * 2.  Defining FORCE_INDIRECT_CONVERTER (see _XlcEucLoader())

- *     forces indirect (charset) conversions (e.g. wcstocs()<->cstombs()).

- * 3.  Using direct converters (e.g. mbstowcs()) decreases conversion

- *     times by 20-40% (depends on specific converter used).

- */

-

-

-static int

-sjis_mbstowcs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-

-    XLCd lcd = (XLCd)conv->state;

-

-    int chr_len = 0;

-    int shift_mult = 0;

-    Uint chrcode = 0;

-

-    Uchar ch, ch2;

-    Uint wc_encode = 0;

-    Uint wc_tmp = 0;

-

-    Bool new_char;

-

-    int firstbyte;

-    int length = 0;

-    int num_conv;

-    int unconv_num = 0;

-

-    const char *inbufptr = *from;

-    wchar_t *outbufptr = (wchar_t *) *to;

-    wchar_t *outbuf_base = outbufptr;

-

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-    int codeset_num = XLC_GENERIC(lcd, codeset_num);

-    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);

-

-    if (*from_left > *to_left)

-	*from_left = *to_left;

-

-     for (new_char = True, firstbyte = True; *from_left > 0; (*from_left)--) {

-

-	ch = *inbufptr++;

-

-	if (firstbyte) {

-	    if (ASCII_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    if (isascii(ch)) {

-		length = CS0->length;

-		*outbufptr++ = (wchar_t)ch;

-		continue;

-	    }

-	    else if (iskanji(ch)) {

-		if (KANJI_CODESET >= codeset_num) {

-		    unconv_num++;

-		    (*from_left)--;

-		    continue;

-		}

-		firstbyte = False;

-		length = CS1->length;

-		if (*from_left < length || *to_left < length)

-		    return -1;

-		wc_encode = CS1->wc_encoding;

-		ch2 = *inbufptr;

-		sjis_to_jis(&ch, &ch2);

-		chrcode = ch;

-	    }

-	    else if (iskana(ch)) {

-		if (KANA_CODESET >= codeset_num) {

-		    unconv_num++;

-		    (*from_left)--;

-		    continue;

-		}

-		length = CS2->length;

-		wc_encode = CS2->wc_encoding;

-		chrcode = BIT8OFF(ch);

-	    }

-	    else if (isuserdef(ch)) {

-		if (USERDEF_CODESET >= codeset_num) {

-		    unconv_num++;

-		    (*from_left)--;

-		    continue;

-		}

-		firstbyte = False;

-		length = CS3->length;

-		if (*from_left < length || *to_left < length)

-		    return -1;

-		wc_encode = CS3->wc_encoding;

-		ch2 = *inbufptr;

-		sjis_to_jis(&ch, &ch2);

-		chrcode = ch;

-	    }

-	    else /* unknown */ {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	} else {	     		/* 2nd byte of multibyte char */

-	    if (!VALID_MULTIBYTE((Uchar) *(inbufptr-1))) {

-		unconv_num++;

-		firstbyte = True;

-	    }

-	    chrcode = ch2;

-	}

-

-	if (new_char) {

-	    chr_len = length;

-	    shift_mult = length - 1;

-	    new_char = False;

-	}

-

-	chrcode <<= (wc_shift * shift_mult);

-	shift_mult--;

-	wc_tmp |= chrcode;

-	if (--chr_len == 0) {

-	    wc_tmp |= wc_encode;

-	    *outbufptr++ = wc_tmp;

-

-	    firstbyte = True;

-	    new_char = True;

-	    wc_tmp = (Uint)0;

-	}

-

-    } /* end for */

-

-    *to = (XPointer)outbufptr;

-

-    if ((num_conv = outbufptr - outbuf_base) > 0)

-	(*to_left) -= num_conv;

-

-    return unconv_num;

-}

-

-

-#define byte1		(length == codeset->length - 1)

-#define byte2		(byte1 == 0)

-

-static int

-sjis_wcstombs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    const wchar_t *inbufptr = (const wchar_t *) *from;

-    XPointer outbufptr = *to;

-    XPointer outbuf_base = outbufptr;

-    wchar_t  wch;

-    int length;

-    Uchar tmp;

-    Uchar t1, t2;

-    int num_conv;

-    int unconv_num = 0;

-

-    XLCd lcd = (XLCd)conv->state;

-    CodeSet codeset;

-    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);

-

-    if (*from_left > *to_left)

-	*from_left = *to_left;

-

-    for (; *from_left > 0 ; (*from_left)-- ) {

-

-	wch = *inbufptr++;

-

-	if (!(codeset = wc_codeset(lcd, wch))) {

-	    unconv_num++;

-	    (*from_left)--;

-	    continue;

-	}

-

-	length = codeset->length;

-	wch ^= (wchar_t)codeset->wc_encoding;

-

-	do {

-	    length--;

-	    tmp = wch>>(wchar_t)( (Ulong)length * wc_shift);

-

-	    if (kana)

-		tmp = BIT8ON(tmp);

-

-	    else if (byte1 && (kanji || userdef)) {

-		t1 = BIT8OFF(tmp);

-		continue;

-	    }

-

-	    else if (byte2 && (kanji || userdef)) {

-		t2 = BIT8OFF(tmp);

-		jis_to_sjis(&t1, &t2);

-		*outbufptr++ = (char)t1;

-		tmp = t2;

-	    }

-

-	    *outbufptr++ = (char)tmp;

-	} while (length);

-

-    }	/* end for */

-

-    *to = (XPointer)outbufptr;

-

-    if ((num_conv = (int)(outbufptr - outbuf_base)) > 0)

-	(*to_left) -= num_conv;

-

-    return unconv_num;

-}

-#undef byte1

-#undef byte2

-

-/*

- * sjis<->jis conversion for widechar kanji (See Note at top of file)

- */

-static void

-sjis_to_jis(

-    Uchar *p1,

-    Uchar *p2)

-{

-  Uchar c1 = *p1;

-  Uchar c2 = *p2;

-  Uchar adjust = c2 < 0x9f;

-  Uchar rowOffset = c1 < 0xa0 ? 0x70 : 0xb0;

-  Uchar cellOffset = adjust ? (0x1f + (c2 > 0x7f)) : 0x7e;

-

-  *p1 = ((c1 - rowOffset) << 1) - adjust;

-  *p2 -= cellOffset;

-}

-

-static void

-jis_to_sjis(

-    Uchar *p1,

-    Uchar *p2)

-{

-  Uchar c1 = *p1;

-  Uchar c2 = *p2;

-  Uchar rowOffset = c1 < 0x5f ? 0x70 : 0xb0;

-  Uchar cellOffset = c1 % 2 ? 0x1f + (c2 > 0x5f) : 0x7e;

-

-  *p1 = ((Uchar)(c1 + 1) >> 1) + rowOffset;

-  *p2 = c2 + cellOffset;

-}

-

-static CodeSet

-wc_codeset(

-    XLCd lcd,

-    wchar_t wch)

-{

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-#if !defined(__sony_news)  ||  defined(SVR4)

-    int end = XLC_GENERIC(lcd, codeset_num);

-    Ulong widech = (Ulong)(wch & XLC_GENERIC(lcd, wc_encode_mask));

-

-    for (; --end >= 0; codesets++)

-	if ( widech == (*codesets)->wc_encoding )

-	    return *codesets;

-

-    return NULL;

-#else

-    if( iskanji(wch >> 8) )

-	return( codesets[1] );

-    if( iskana(wch & 0xff) )

-	return( codesets[2] );

-    return( codesets[0] );

-#endif

-}

-

-

-static int

-sjis_mbtocs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-    XlcCharSet charset = NULL;

-    int char_size = 0;

-    int unconv_num = 0;

-    const char *src = *from;

-    char *dst = *to;

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-    int codeset_num = XLC_GENERIC(lcd, codeset_num);

-

-    if (iskanji(*src)) {

-	if (KANJI_CODESET >= codeset_num)

-	    return -1;

-	charset = *CS1->charset_list;

-	char_size = charset->char_size;

-

-	if (*from_left >= char_size && *to_left >= char_size) {

-	    *dst++ = *src++;

-	    *dst++ = *src++;

-	    if (!VALID_MULTIBYTE((Uchar) *(src-1))) /* check 2nd byte */

-		unconv_num++;

-	    sjis_to_jis((Uchar *)(dst-2), (Uchar *)(dst-1));

-	} else

-	    return -1;

-    }

-    else if (isuserdef(*src)) {

-	if (USERDEF_CODESET >= codeset_num)

-	    return -1;

-	charset = *CS3->charset_list;

-	char_size = charset->char_size;

-

-	if (*from_left >= char_size && *to_left >= char_size) {

-	    *dst++ = *src++;

-	    *dst++ = *src++;

-	    if (!VALID_MULTIBYTE((Uchar) *(src-1))) /* check 2nd byte */

-		unconv_num++;

-	    sjis_to_jis((Uchar *)(dst-2), (Uchar *)(dst-1));

-	} else

-	    return -1;

-    }

-    else if (isascii(*src)) {

-	if (ASCII_CODESET >= codeset_num)

-	    return -1;

-	charset = *CS0->charset_list;

-	char_size = charset->char_size;

-

-	if (*from_left >= char_size && *to_left >= char_size)

-	    *dst++ = *src++;

-	else

-	    return -1;

-    }

-    else if (iskana(*src)) {

-	if (KANA_CODESET >= codeset_num)

-	    return  -1;

-	charset = *CS2->charset_list;

-	char_size = charset->char_size;

-

-	if (*from_left >= char_size && *to_left >= char_size)

-	    *dst++ = *src++;

-	else

-	   return -1;

-    }

-    else 	/* unknown */

-	return -1;

-

-    *from_left -= char_size;

-    *to_left -= char_size;

-

-    *to = (XPointer) dst;

-    *from = (XPointer) src;

-

-    if (num_args > 0)

-	*((XlcCharSet *) args[0]) = charset;

-

-    return unconv_num;

-}

-

-

-static int

-sjis_mbstocs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    const char *tmp_from;

-    char *tmp_to;

-    int tmp_from_left, tmp_to_left;

-    XlcCharSet charset, tmp_charset;

-    XPointer tmp_args[1];

-    int unconv_num = 0, ret;

-

-/* Determine the charset of the segment and convert one character: */

-

-    tmp_args[0] = (XPointer) &charset; /* charset from sjis_mbtocs() */

-    while

-      ((ret = sjis_mbtocs(conv, from, from_left, to, to_left, tmp_args, 1)) > 0)

-	unconv_num += ret;

-    if ( ret < 0 )

-	return ret;

-

-    tmp_from = *from;

-    tmp_from_left = *from_left;

-    tmp_to_left = *to_left;

-    tmp_to = *to;

-

-/* Convert remainder of the segment: */

-

-    tmp_args[0] = (XPointer) &tmp_charset;

-    while( (ret = sjis_mbtocs(conv, (XPointer *) &tmp_from, &tmp_from_left,

-		     (XPointer *) &tmp_to, &tmp_to_left, tmp_args, 1)) >= 0 ) {

-

-	if (ret > 0) {

-	    unconv_num += ret;

-	    continue;

-	}

-

-	if (tmp_charset != charset)  /* quit on end of segment */

-	    break;

-

-	*from = (XPointer) tmp_from;

-	*from_left = tmp_from_left;

-	*to = (XPointer) tmp_to;

-	*to_left = tmp_to_left;

-    }

-

-    if (num_args > 0)

-	*((XlcCharSet *) args[0]) = charset;

-

-    return unconv_num;

-}

-

-static int

-sjis_wcstocs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd) conv->state;

-    const wchar_t *wcptr = *((const wchar_t **)from);

-    char *bufptr = *((char **) to);

-    wchar_t wch;

-    char *tmpptr;

-    int length;

-    CodeSet codeset;

-    Ulong wc_encoding;

-    int buf_len = *to_left;

-    int wcstr_len = *from_left;

-

-    if (!(codeset = wc_codeset(lcd, *wcptr)))

-	return -1;

-

-    if (wcstr_len < buf_len / codeset->length)

-	buf_len = wcstr_len * codeset->length;

-

-#if !defined(__sony_news)  ||  defined(SVR4)

-    wc_encoding = codeset->wc_encoding;

-

-    for ( ; wcstr_len > 0 && buf_len > 0; wcptr++, wcstr_len--) {

-	wch = *wcptr;

-

-	if ((wch & XLC_GENERIC(lcd, wc_encode_mask)) != wc_encoding)

-	    break;

-

-	length = codeset->length;

-

-	buf_len -= length;

-	bufptr += length;

-	tmpptr = bufptr - 1;

-

-	while (length--) {

-	    *tmpptr-- = kana ? BIT8ON(wch) : BIT8OFF(wch);

-	    wch >>= (wchar_t)XLC_GENERIC(lcd, wc_shift_bits);

-	}

-    }

-#else

-    length = codeset->length;

-    for( ; wcstr_len > 0  &&  buf_len > 0; wcptr++, wcstr_len-- ) {

-	wch = *wcptr;

-	if( codeset != wc_codeset( lcd, wch ) )

-	    break;

-

-	buf_len -= length;

-	if( length == 2 ) {

-	    unsigned short	code;

-

-	    code = sjis2jis( wch & 0xffff );

-	    *bufptr++ = code >> 8;

-	    *bufptr++ = code & 0xff;

-	}

-	else

-	    *bufptr++ = wch & 0xff;

-    }

-#endif

-

-    if (num_args > 0)

-	*((XlcCharSet *) args[0]) = *codeset->charset_list;

-

-    *from_left -= wcptr - (wchar_t *) *from;

-    *from = (XPointer) wcptr;

-

-    *to_left -= bufptr - *to;

-    *to = bufptr;

-

-    return 0;

-}

-

-static CodeSet

-GetCodeSetFromCharSet(

-    XLCd lcd,

-    XlcCharSet charset)

-{

-    CodeSet *codeset = XLC_GENERIC(lcd, codeset_list);

-    XlcCharSet *charset_list;

-    int codeset_num, num_charsets;

-

-    codeset_num = XLC_GENERIC(lcd, codeset_num);

-

-    for ( ; codeset_num-- > 0; codeset++) {

-	num_charsets = (*codeset)->num_charsets;

-	charset_list = (*codeset)->charset_list;

-

-	for ( ; num_charsets-- > 0; charset_list++)

-	    if (*charset_list == charset)

-		return *codeset;

-    }

-

-    return (CodeSet) NULL;

-}

-

-

-static int

-sjis_cstombs(

-    XlcConv conv,

-    char **from,

-    int *from_left,

-    char **to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd) conv->state;

-    const char *csptr = *from;

-    char *bufptr = *to;

-    int csstr_len = *from_left;

-    int buf_len = *to_left;

-    int length;

-    CodeSet codeset;

-    int cvt_length = 0;

-

-    if (num_args < 1)

-	return -1;

-

-    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))

-	return -1;

-

-    csstr_len /= codeset->length;

-    buf_len /= codeset->length;

-    if (csstr_len < buf_len)

-	buf_len = csstr_len;

-

-    cvt_length += buf_len * codeset->length;

-

-    if (bufptr) {

-	while (buf_len--) {

-	    length = codeset->length;

-	    while (length--)

-		*bufptr++ = codeset->length == 1 && codeset->side == XlcGR ?

-		  BIT8ON(*csptr++) : BIT8OFF(*csptr++);

-

-	    if (codeset->length == 2)

-		jis_to_sjis((Uchar *)(bufptr-2), (Uchar *)(bufptr-1));

-	}

-    }

-

-    *from_left -= csptr - *from;

-    *from = (XPointer) csptr;

-

-    if (bufptr)

-	*to += cvt_length;

-    *to_left -= cvt_length;

-

-

-    return 0;

-}

-

-static int

-sjis_cstowcs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd) conv->state;

-    const char *csptr = (const char *) *from;

-    wchar_t *bufptr = (wchar_t *) *to;

-    wchar_t *toptr = (wchar_t *) *to;

-    int csstr_len = *from_left;

-    int buf_len = *to_left;

-    wchar_t wch;

-    int length;

-    Ulong wc_shift_bits = (int)XLC_GENERIC(lcd, wc_shift_bits);

-    CodeSet codeset;

-

-    if (num_args < 1)

-	return -1;

-

-    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))

-	return -1;

-

-    csstr_len /= codeset->length;

-    if (csstr_len < buf_len)

-	buf_len = csstr_len;

-

-    *to_left -= buf_len;

-

-    if (bufptr) {

-

-	toptr += buf_len;

-	*to = (XPointer) toptr;

-

-	while (buf_len--) {

-	    wch = (wchar_t) BIT8OFF(*csptr);

-	    csptr++;

-

-	    length = codeset->length - 1;

-	    while (length--) {

-		wch = (wch << wc_shift_bits) | BIT8OFF(*csptr);

-		csptr++;

-	    }

-	    *bufptr++ = wch | codeset->wc_encoding;

-	}

-    }

-

-    *from_left -= csptr - *from;

-    *from = (XPointer) csptr;

-

-    return 0;

-}

-

-

-/*

- *    Stripped down Direct CT converters for SJIS

- *

- */

-

-#define BADCHAR(min_ch, c)  (BIT8OFF(c) < (char)min_ch && BIT8OFF(c) != 0x0 && \

-			     BIT8OFF(c) != '\t' && BIT8OFF(c) != '\n' && \

-			     BIT8OFF(c) != 0x1b)

-

-typedef struct _CTDataRec {

-    int side;

-    int length;

-    char *name;

-    Ulong wc_encoding;

-    char *ct_encoding;

-    int ct_encoding_len;

-    int set_size;

-    Uchar min_ch;

-    Uchar ct_type;

-} CTDataRec, *CTData;

-

-typedef struct _StateRec {

-    CTData GL_charset;

-    CTData GR_charset;

-    CTData charset;

-} StateRec, *State;

-

-#define CT_STD  0

-#define CT_NSTD 1

-#define CT_DIR  2

-#define CT_EXT0 3

-#define CT_EXT1 4

-#define CT_EXT2 5

-#define CT_VER  6

-

-static CTDataRec ctdata[] =

-{

-    { XlcGL,      1, "ISO8859-1:GL",       0, "\033(B"   ,  3, 0, 0, CT_STD  },

-    { XlcGR,      1, "ISO8859-1:GR",       0, "\033-A"   ,  3, 0, 0, CT_STD  },

-    { XlcGL,      1, "JISX0201.1976-0:GL", 0, "\033(J"   ,  3, 0, 0, CT_STD  },

-    { XlcGR,      1, "JISX0201.1976-0:GR", 0, "\033)I"   ,  3, 0, 0, CT_STD  },

-    { XlcGL,      2, "JISX0208.1983-0:GL", 0, "\033$(B"  ,  4, 0, 0, CT_STD  },

-    { XlcGR,      2, "JISX0208.1983-0:GR", 0, "\033$)B"  ,  4, 0, 0, CT_STD  },

-    { XlcGL,      2, "JISX0212.1990-0:GL", 0, "\033$(D"  ,  4, 0, 0, CT_STD  },

-    { XlcGR,      2, "JISX0212.1990-0:GR", 0, "\033$)D"  ,  4, 0, 0, CT_STD  },

-    { XlcUnknown, 0, "Ignore-Ext-Status?", 0, "\033#"    ,  2, 0, 0, CT_VER  },

-    { XlcUnknown, 0, "NonStd-?-OctetChar", 0, "\033%/0"  ,  4, 0, 0, CT_NSTD },

-    { XlcUnknown, 1, "NonStd-1-OctetChar", 0, "\033%/1"  ,  4, 0, 0, CT_NSTD },

-    { XlcUnknown, 2, "NonStd-2-OctetChar", 0, "\033%/2"  ,  4, 0, 0, CT_NSTD },

-    { XlcUnknown, 3, "NonStd-3-OctetChar", 0, "\033%/3"  ,  4, 0, 0, CT_NSTD },

-    { XlcUnknown, 4, "NonStd-4-OctetChar", 0, "\033%/4"  ,  4, 0, 0, CT_NSTD },

-    { XlcUnknown, 0, "Extension-2"       , 0, "\033%/"   ,  3, 0, 0, CT_EXT2 },

-    { XlcUnknown, 0, "Extension-0"       , 0, "\033"     ,  1, 0, 0, CT_EXT0 },

-    { XlcUnknown, 0, "Begin-L-to-R-Text",  0, "\2331]"   ,  3, 0, 0, CT_DIR  },

-    { XlcUnknown, 0, "Begin-R-to-L-Text",  0, "\2332]"   ,  3, 0, 0, CT_DIR  },

-    { XlcUnknown, 0, "End-Of-String",      0, "\233]"    ,  2, 0, 0, CT_DIR  },

-    { XlcUnknown, 0, "Extension-1"       , 0, "\233"     ,  1, 0, 0, CT_EXT1 },

-};

-

-/* Note on above table:  sjis_ctstombs() and sjis_ctstowcs() parser depends on

- * certain table entries occuring in decreasing string length--

- *   1.  CT_EXT2 and CT_EXT0 entries must occur after CT_NSTD entries.

- *   2.  CT_DIR and CT_EXT1 entries must occur after CT_DIR entries.

- */

-

-static CTData ctdptr[sizeof(ctdata) / sizeof(CTDataRec)];

-static CTData ctd_endp = ctdata + ((sizeof(ctdata) / sizeof(CTDataRec))) - 1;

-

-#define Ascii   0

-#define Kanji   1

-#define Kana    2

-#define Userdef 3

-

-/*

- * initCTptr(): Set ctptr[] to point at ctdata[], indexed by codeset_num.

- */

-static void

-initCTptr(

-    XLCd lcd)

-{

-    int num_codesets = XLC_GENERIC(lcd, codeset_num);

-    int num_charsets;

-    int i, j;

-    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);

-    CodeSet codeset;

-    XlcCharSet charset;

-    CTData ctdp = ctdata;

-

-    ctdptr[Ascii] = &ctdata[0];         /* failsafe */

-

-    for (i = 0; i < num_codesets; i++) {

-

-	codeset = codesets[i];

-	num_charsets = codeset->num_charsets;

-

-	for (j = 0; j < num_charsets; j++) {

-

-	    charset = codeset->charset_list[j];

-

-	    for (ctdp = ctdata; ctdp <= ctd_endp; ctdp++)

-

-		if (! strcmp(ctdp->name, charset->name)) {

-

-		    ctdptr[codeset->cs_num] = ctdp;

-

-		    ctdptr[codeset->cs_num]->wc_encoding = codeset->wc_encoding;

-

-		    ctdptr[codeset->cs_num]->set_size =

-		      charset->set_size;

-

-		    ctdptr[codeset->cs_num]->min_ch =

-		      charset->set_size == 94 &&

-		      (ctdptr[codeset->cs_num]->length > 1 ||

-		      ctdptr[codeset->cs_num]->side == XlcGR) ? 0x21 : 0x20;

-

-		    break;

-		}

-	}

-    }

-}

-

-

-static int

-sjis_mbstocts(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    int ct_len = *to_left;

-    int cs_num;

-    int clen;

-    int unconv_num = 0;

-    int num_conv;

-    const char *inbufptr = *from;

-    char *ctptr = *to;

-    XPointer ct_base = ctptr;

-

-    StateRec ct_state;

-    CTData charset = NULL;

-    XLCd lcd = (XLCd) conv->state;

-    int codeset_num = XLC_GENERIC(lcd, codeset_num);

-

-/* Initial State: */

-

-    ct_state.GL_charset = ctdptr[Ascii];

-    ct_state.GR_charset = NULL;

-

-    if (*from_left > *to_left)

-        *from_left = *to_left;

-

-    for (;*from_left > 0; (*from_left) -= charset->length) {

-

-	if (iskanji(*inbufptr)) {

-	    if (KANJI_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Kanji;

-	    charset = ctdptr[Kanji];

-	    if (!VALID_MULTIBYTE((Uchar) *(inbufptr+1)))

-		unconv_num++;

-	}

-	else if (isuserdef(*inbufptr)) {

-	    if (USERDEF_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Userdef;

-	    charset = ctdptr[Userdef];

-	    if (!VALID_MULTIBYTE((Uchar) *(inbufptr+1)))

-		unconv_num++;

-	}

-	else if (isascii(*inbufptr)) {

-	    if (ASCII_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Ascii;

-	    charset = ctdptr[Ascii];

-	}

-	else if (iskana(*inbufptr)) {

-	    if (KANA_CODESET >= codeset_num) {

-		unconv_num++;

-		(*from_left)--;

-		continue;

-	    }

-	    cs_num = Kana;

-	    charset = ctdptr[Kana];

-	}

-	else { 		 /* unknown */

-	    unconv_num++;

-	    (*from_left)--;

-	    continue;

-	}

-

-	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||

-	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {

-

-	    ct_len -= ctdptr[cs_num]->ct_encoding_len;

-	    if (ct_len < 0) {

-		unconv_num++;

-		break;

-	    }

-

-	    if (ctptr) {

-		strcpy(ctptr, ctdptr[cs_num]->ct_encoding);

-		ctptr += ctdptr[cs_num]->ct_encoding_len;

-	    }

-	}

-

-	clen = charset->length;

-	do {

-	    *ctptr++ = *inbufptr++;

-	} while (--clen);

-

-	if (charset->length >= 2) {

-	    sjis_to_jis((Uchar *)(ctptr-2), (Uchar *)(ctptr-1));

-	    if (BADCHAR(charset->min_ch, *(ctptr-2)) ||

-		  BADCHAR(charset->min_ch, *(ctptr-1))) {

-		unconv_num++;

-		continue;

-	    }

-	}

-	else

-	    if (BADCHAR(charset->min_ch, *(ctptr-1))) {

-		unconv_num++;

-		continue;

-	    }

-

-	if (charset->side == XlcGR)

-	    ct_state.GR_charset = charset;

-	else if (charset->side == XlcGL)

-	    ct_state.GL_charset = charset;

-

-	if (charset->side == XlcGR) {

-	  clen = charset->length;

-	  do {

-	    (*(Uchar *)(ctptr-clen)) = BIT8ON(*(Uchar *)(ctptr-clen));

-	  } while (--clen);

-	}

-    }

-

-    *to = (XPointer)ctptr;

-

-    if ((num_conv = (int)(ctptr - ct_base)) > 0)

-	(*to_left) -= num_conv;

-

-    return unconv_num;

-

-}

-

-

-#define byte1		(length == codeset->length - 1)

-#define byte2		(byte1 == 0)

-

-static int

-sjis_wcstocts(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    int ct_len = *to_left;

-    const wchar_t *inbufptr = (const wchar_t *) *from;

-    char *ctptr = *to;

-    XPointer ct_base = ctptr;

-    wchar_t  wch;

-    int length;

-    Uchar tmp;

-    Uchar t1 = 0;

-    int num_conv;

-

-    StateRec ct_state;

-    XLCd lcd = (XLCd)conv->state;

-    CTData charset;

-    CodeSet codeset;

-    int unconv_num = 0;

-    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);

-

-/* Initial State: */

-    ct_state.GL_charset = ctdptr[0]; /* Codeset 0 */

-    ct_state.GR_charset = NULL;

-

-    if (*from_left > *to_left)

-	*from_left = *to_left;

-

-    for (; *from_left > 0 ; (*from_left)-- ) {

-

-	wch = *inbufptr++;

-

-        if (!(codeset = wc_codeset(lcd, wch))) {

-            unconv_num++;

-            (*from_left)--;

-            continue;

-        }

-

-	charset = ctdptr[codeset->cs_num];

-

-	length = codeset->length;

-	wch ^= (wchar_t)codeset->wc_encoding;

-

-	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||

-	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {

-

-	    ct_len -= ctdptr[codeset->cs_num]->ct_encoding_len;

-	    if (ct_len < 0) {

-		unconv_num++;

-		break;

-	    }

-

-	    if (ctptr) {

-		strcpy(ctptr, ctdptr[codeset->cs_num]->ct_encoding);

-		ctptr += ctdptr[codeset->cs_num]->ct_encoding_len;

-	    }

-

-	}

-

-	if (charset->side == XlcGR)

-	    ct_state.GR_charset = charset;

-	else if (charset->side == XlcGL)

-	    ct_state.GL_charset = charset;

-

-	do {

-	    length--;

-	    tmp = wch>>(wchar_t)( (Ulong)length * wc_shift);

-

-	    if (kana) {

-		if (BADCHAR(charset->min_ch, (char)tmp)) {

-		    unconv_num++;

-		    break;

-		}

-		*ctptr++ = (char)BIT8ON(tmp);

-	    }

-

-	    else if (byte1 && (kanji || userdef)) {

-		t1 = tmp;

-	    }

-

-	    else if (byte2 && (kanji || userdef)) {

-		if (BADCHAR(charset->min_ch, (char)t1) ||

-		  BADCHAR(charset->min_ch, (char)tmp)) {

-		    unconv_num++;

-		    break;

-		}

-

-		*ctptr++ = (char)BIT8OFF(t1);

-		*ctptr++ = (char)BIT8OFF(tmp);

-	    }

-

-	    else {

-		if (BADCHAR(charset->min_ch, (char)tmp)) {

-		    unconv_num++;

-		    break;

-		}

-		*ctptr++ = (char)tmp;

-	    }

-	} while (length);

-

-    }	/* end for */

-

-    *to = (XPointer)ctptr;

-

-    if ((num_conv = (int)(ctptr - ct_base)) > 0)

-	(*to_left) -= num_conv;

-

-    return unconv_num;

-}

-#undef byte1

-#undef byte2

-

-#define SKIP_I(str)	while (*(str) >= 0x20 && *(str) <=  0x2f) (str)++;

-#define SKIP_P(str)	while (*(str) >= 0x30 && *(str) <=  0x3f) (str)++;

-

-static int

-sjis_ctstombs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    const char *inbufptr =  *from;

-    XPointer outbufptr =  *to;

-    const char *inbuf_base;

-    XPointer outbuf_base = outbufptr;

-    int clen, length;

-    int unconv_num = 0;

-    int num_conv;

-    unsigned int ct_seglen = 0;

-    Uchar ct_type;

-    CTData ctdp = ctdata;	/* default */

-    CTData GL_ctdp = ctdp;	/* GL ctdp save */

-    CTData GR_ctdp = ctdp;	/* GR ctdp save */

-

-    if (*from_left > *to_left)

-	*from_left = *to_left;

-

-    for (length = ctdata[Ascii].length; *from_left > 0 ; (*from_left) -= length)

-    {

-	ct_type = CT_STD;

-	/* change GL/GR charset */

-	if(ctdp->side == XlcGR && isleftside(*inbufptr)){

-	    /* select GL side */

-	    ctdp = GL_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){

-	    /* select GR side */

-	    ctdp = GR_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}

-	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {

-

-	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {

-

-		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))

-		{

-		    inbufptr += ctdp->ct_encoding_len;

-		    (*from_left) -= ctdp->ct_encoding_len;

-		    if( ctdp->length ) {

-			length = ctdp->length;

-			if( *from_left < length ) {

-			    *to = (XPointer)outbufptr;

-			    *to_left -= outbufptr - outbuf_base;

-			    return( unconv_num + *from_left );

-			}

-		    }

-		    ct_type = ctdp->ct_type;

-		    if(ctdp->side == XlcGL){

-			GL_ctdp = ctdp; /* save GL ctdp */

-		    }else{

-			GR_ctdp = ctdp; /* save GR ctdp */

-		    }

-		    break;

-		}

-	    }

-	    if (ctdp > ctd_endp)  	/* failed to match CT sequence */

-		unconv_num++;

-	}

-

-/* The following code insures that non-standard encodings, direction, extension,

- * and version strings are ignored; subject to change in future.

- */

-	switch (ct_type) {

-	  case CT_STD:

-	    break;

-	  case CT_EXT2:

-	    inbufptr++;

-	    (*from_left)--;

-	  case CT_NSTD:

-	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;

-	    inbufptr += ct_seglen;

-	    (*from_left) -= ct_seglen;

-	    continue;

-	  case CT_EXT0:

-	    inbuf_base = inbufptr;

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    (*from_left) -= ct_seglen;

-	    continue;

-	  case CT_EXT1:

-	    inbuf_base = inbufptr;

-	    SKIP_P(inbufptr);

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    (*from_left) -= ct_seglen;

-	    continue;

-	  case CT_DIR:

-	    continue;

-	  case CT_VER:

-	    inbufptr += 2;

-	    (*from_left) -= 2;

-	    continue;

-	}

-

-	if (ctdp->side == XlcGL || isrightside (*inbufptr)) {

-	    clen = length;

-	} else {

-	    clen = 1;

-	    *from_left += length - clen;

-	}

-	do {

-	    Uchar mask = (length == 2) ? GL : -1;

-	    *outbufptr++ = *inbufptr++ & mask;

-	} while (--clen);

-

-	if (length >= 2)

-	    jis_to_sjis((Uchar *)(outbufptr-2), (Uchar *)(outbufptr-1));

-    }

-

-    *to = (XPointer)outbufptr;

-

-    if ((num_conv = (int)(outbufptr - outbuf_base)) > 0)

-	(*to_left) -= num_conv;

-

-    return unconv_num;

-}

-

-

-static int

-sjis_ctstowcs(

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XLCd lcd = (XLCd)conv->state;

-    Ulong wc_shift_bits = XLC_GENERIC(lcd, wc_shift_bits);

-    const char *inbufptr = *from;

-    const char *inbuf_base;

-    wchar_t *outbufptr = (wchar_t *) *to;

-    wchar_t *outbuf_base = outbufptr;

-    int clen, length;

-    int num_conv;

-    int unconv_num = 0;

-    unsigned int ct_seglen = 0;

-    Uchar ct_type = 0;

-    int shift_mult;

-    wchar_t wc_tmp;

-    wchar_t wch;

-    Ulong wc_encoding;

-    CTData ctdp = ctdata;

-    CTData GL_ctdp = ctdp;	/* GL ctdp save */

-    CTData GR_ctdp = ctdp;	/* GR ctdp save */

-

-    if (*from_left > *to_left)

-	*from_left = *to_left;

-

-    for (length = ctdata[Ascii].length; *from_left > 0; (*from_left) -= length )

-    {

-	ct_type = CT_STD;

-	/* change GL/GR charset */

-	if(ctdp->side == XlcGR && isleftside(*inbufptr)){

-	    /* select GL side */

-	    ctdp = GL_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){

-	    /* select GR side */

-	    ctdp = GR_ctdp;

-	    length = ctdp->length;

-	    ct_type = ctdp->ct_type;

-	}

-	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {

-	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {

-

-		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))

-		{

-		    inbufptr += ctdp->ct_encoding_len;

-		    (*from_left) -= ctdp->ct_encoding_len;

-		    if( ctdp->length ) {

-			length = ctdp->length;

-			if( *from_left < length ) {

-			    *to = (XPointer)outbufptr;

-			    *to_left -= outbufptr - outbuf_base;

-			    return( unconv_num + *from_left );

-			}

-		    }

-		    ct_type = ctdp->ct_type;

-		    if(ctdp->side == XlcGL){

-			GL_ctdp = ctdp; /* save GL ctdp */

-		    }else{

-			GR_ctdp = ctdp; /* save GR ctdp */

-		    }

-		    break;

-		}

-	    }

-	    if (ctdp > ctd_endp)    	/* failed to match CT sequence */

-		unconv_num++;

-	}

-

-/* The following block of code insures that non-standard encodings, direction,

- * extension, and version strings are ignored; subject to change in future.

- */

-	switch (ct_type) {

-	  case CT_STD:

-	    break;

-	  case CT_EXT2:

-	    inbufptr++;

-	    (*from_left)--;

-	  case CT_NSTD:

-	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;

-	    inbufptr += ct_seglen;

-	    (*from_left) -= ct_seglen;

-	    continue;

-	  case CT_EXT0:

-	    inbuf_base = inbufptr;

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    (*from_left) -= ct_seglen;

-	    continue;

-	  case CT_EXT1:

-	    inbuf_base = inbufptr;

-	    SKIP_P(inbufptr);

-	    SKIP_I(inbufptr);

-	    inbufptr++;

-	    ct_seglen = (unsigned)(inbufptr - inbuf_base);

-	    (*from_left) -= ct_seglen;

-	    continue;

-	  case CT_DIR:

-	    continue;

-	  case CT_VER:

-	    inbufptr += 2;

-	    (*from_left) -= 2;

-	    continue;

-	}

-#if !defined(__sony_news)  ||  defined(SVR4)

-	if (ctdp->side == XlcGL || isrightside (*inbufptr)) {

-	    clen = length;

-	    wc_encoding = ctdp->wc_encoding;

-	} else {

-	    clen = 1;

-	    *from_left += length - clen;

-	    wc_encoding = ctdptr[Ascii]->wc_encoding;

-	}

-	shift_mult = clen - 1;

-	wch = (wchar_t)0;

-

-	do {

-	    wc_tmp = BIT8OFF(*inbufptr++) << (wc_shift_bits * shift_mult);

-	    wch |= wc_tmp;

-	    shift_mult--;

-	} while (--clen);

-	*outbufptr++ = wch | wc_encoding;

-#else

-	if( length == 1 )

-	    *outbufptr++ = (unsigned char)*inbufptr++;

-	else if( length == 2 ) {

-	    unsigned short	code;

-	    code = (*inbufptr << 8) | *(inbufptr+1);

-	    *outbufptr++ = jis2sjis( code );

-	    inbufptr += 2;

-	}

-#endif

-    }

-    *to = (XPointer)outbufptr;

-

-    if ((num_conv = (int)(outbufptr - outbuf_base)) > 0)

-	(*to_left) -= num_conv ;

-

-    return unconv_num;

-

-}

-#undef BADCHAR

-

-static void

-close_converter(

-    XlcConv conv)

-{

-	Xfree((char *) conv);

-}

-

-

-static XlcConv

-create_conv(

-    XLCd lcd,

-    XlcConvMethods methods)

-{

-    XlcConv conv;

-

-    conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));

-    if (conv == NULL)

-	return (XlcConv) NULL;

-

-    conv->methods = methods;

-    conv->state = (XPointer) lcd;

-    return conv;

-}

-

-

-enum { MBSTOCS, WCSTOCS, MBTOCS, CSTOMBS, CSTOWCS, MBSTOWCS, WCSTOMBS,

-       WCSTOCTS, MBSTOCTS, CTSTOMBS, CTSTOWCS };

-

-static XlcConvMethodsRec conv_methods[] = {

-    {close_converter, sjis_mbstocs,  NULL },

-    {close_converter, sjis_wcstocs,  NULL },

-    {close_converter, sjis_mbtocs,   NULL },

-    {close_converter, sjis_cstombs,  NULL },

-    {close_converter, sjis_cstowcs,  NULL },

-    {close_converter, sjis_mbstowcs, NULL },

-    {close_converter, sjis_wcstombs, NULL },

-    {close_converter, sjis_wcstocts, NULL },

-    {close_converter, sjis_mbstocts, NULL },

-    {close_converter, sjis_ctstombs, NULL },

-    {close_converter, sjis_ctstowcs, NULL },

-};

-

-

-static XlcConv

-open_mbstocs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBSTOCS]);

-}

-

-static XlcConv

-open_wcstocs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[WCSTOCS]);

-}

-

-static XlcConv

-open_mbtocs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBTOCS]);

-}

-

-static XlcConv

-open_cstombs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CSTOMBS]);

-}

-

-static XlcConv

-open_cstowcs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CSTOWCS]);

-}

-

-static XlcConv

-open_mbstowcs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBSTOWCS]);

-}

-

-static XlcConv

-open_wcstombs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[WCSTOMBS]);

-}

-

-static XlcConv

-open_wcstocts(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[WCSTOCTS]);

-}

-

-static XlcConv

-open_mbstocts(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[MBSTOCTS]);

-}

-

-static XlcConv

-open_ctstombs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CTSTOMBS]);

-}

-

-static XlcConv

-open_ctstowcs(

-    XLCd from_lcd,

-    const char *from_type,

-    XLCd to_lcd,

-    const char *to_type)

-{

-    return create_conv(from_lcd, &conv_methods[CTSTOWCS]);

-}

-

-XLCd

-_XlcSjisLoader(

-    const char *name)

-{

-    XLCd lcd;

-

-    lcd = _XlcCreateLC(name, _XlcGenericMethods);

-    if (lcd == NULL)

-	return lcd;

-

-    if (!XLC_PUBLIC_PART(lcd)->codeset ||

-	(_XlcCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "SJIS"))) {

-	_XlcDestroyLC(lcd);

-	return (XLCd) NULL;

-    }

-

-    initCTptr(lcd);

-

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_mbstocs);

-    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstocs);

-    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_cstombs);

-    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_cstowcs);

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_mbtocs);

-

-#ifndef FORCE_INDIRECT_CONVERTER

-    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNMultiByte, open_ctstombs);

-    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNWideChar, open_ctstowcs);

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCompoundText, open_mbstocts);

-    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_mbstowcs);

-    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCompoundText, open_wcstocts);

-    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_wcstombs);

-#endif

-

-    _XlcAddUtf8Converters(lcd);

-

-    return lcd;

-}

-

-#else

-typedef int dummy;

-#endif /* X_LOCALE */

+/****************************************************************
+
+        Copyright 1992, 1993 by FUJITSU LIMITED
+        Copyright 1993 by Fujitsu Open Systems Solutions, Inc.
+	Copyright 1994 by Sony Corporation
+
+Permission to use, copy, modify, distribute and sell this software
+and its documentation for any purpose is hereby granted without fee,
+provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear
+in supporting documentation, and that the name of FUJITSU LIMITED,
+Fujitsu Open Systems Solutions, Inc. and Sony Corporation  not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+FUJITSU LIMITED, Fujitsu Open Systems Solutions, Inc. and
+Sony Corporation make no representations about the suitability of
+this software for any purpose.  It is provided "as is" without
+express or implied warranty.
+
+FUJITSU LIMITED, FUJITSU OPEN SYSTEMS SOLUTIONS, INC. AND SONY
+CORPORATION DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
+IN NO EVENT SHALL FUJITSU OPEN SYSTEMS SOLUTIONS, INC., FUJITSU LIMITED
+AND SONY CORPORATION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
+OR PERFORMANCE OF THIS SOFTWARE.
+
+    Authors: Jeffrey Bloomfield		(jeffb@ossi.com)
+	     Shigeru Yamada		(yamada@ossi.com)
+             Yoshiyuki Segawa		(segawa@ossi.com)
+    Modifier:Makoto Wakamatsu   Sony Corporation
+				makoto@sm.sony.co.jp
+
+*****************************************************************/
+
+/*
+ * A Japanese SJIS locale.
+ * Supports: all locales with codeset SJIS.
+ * How: Provides converters for SJIS.
+ * Platforms: Only those defining X_LOCALE (only Lynx, Linux-libc5, OS/2).
+ */
+
+#ifdef X_LOCALE
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XlcGeneric.h"
+
+#include <ctype.h>
+#ifdef WIN32
+#define isascii __isascii
+#endif
+
+#define CS0	codesets[0]		/* Codeset 0 - 7-bit ASCII	*/
+#define CS1	codesets[1]		/* Codeset 1 - Kanji		*/
+#define CS2	codesets[2]		/* Codeset 2 - Half-Kana	*/
+#define CS3	codesets[3]		/* Codeset 3 - User defined	*/
+
+#define ascii		(codeset->cs_num == 0)
+#define kanji		(codeset->cs_num == 1)
+#define kana		(codeset->cs_num == 2)
+#define userdef		(codeset->cs_num == 3)
+
+#define	ASCII_CODESET	0
+#define KANJI_CODESET	1
+#define KANA_CODESET	2
+#define USERDEF_CODESET	3
+#define MAX_CODESETS	4
+
+#define GR	0x80	/* begins right-side (non-ascii) region */
+#define GL	0x7f    /* ends left-side (ascii) region        */
+
+#define isleftside(c)	(((c) & GR) ? 0 : 1)
+#define isrightside(c)	(!isleftside(c))
+
+typedef unsigned char   Uchar;
+typedef unsigned long	Ulong;
+typedef unsigned int	Uint;
+
+/* Acceptable range for 2nd byte of SJIS multibyte char */
+#define VALID_MULTIBYTE(c) \
+			((0x40<=((Uchar)c) && ((Uchar)c)<=0x7e) \
+			|| (0x80<=((Uchar)c) && ((Uchar)c)<=0xfc))
+
+#ifndef iskanji
+#define iskanji(c)	((0x81<=((Uchar)c) && ((Uchar)c)<=0x9f) \
+			|| (0xe0<=((Uchar)c) && ((Uchar)c)<=0xef))
+#endif /* !iskanji */
+
+#ifndef iskana
+#define iskana(c)	(0xa1<=((Uchar)c) && ((Uchar)c)<=0xdf)
+#endif /* !iskana */
+
+#define	isuserdef(c)	(0xf0<=((Uchar)c) && ((Uchar)c)<=0xfc)
+
+#define BIT8OFF(c)	((c) & GL)
+#define BIT8ON(c)	((c) | GR)
+
+
+static void jis_to_sjis (Uchar *p1, Uchar *p2);
+static void sjis_to_jis (Uchar *p1, Uchar *p2);
+static CodeSet wc_codeset (XLCd lcd, wchar_t wch);
+
+
+/*
+ * Notes:
+ * 1.  16-bit widechar format is limited to 14 data bits.  Since the 2nd byte
+ *     of SJIS multibyte chars are in the ranges of 0x40 - 7E and 0x80 - 0xFC,
+ *     SJIS cannot map directly into 16 bit widechar format within the confines
+ *     of a single codeset.  Therefore, for SJIS widechar conversion, SJIS Kanji
+ *     is mapped into the JIS codeset.  (The algorithms used in jis_to_sjis()
+ *     and sjis_to_jis() are from Ken Lunde (lunde@mv.us.adobe.com) and are in
+ *     the public domain.)
+ * 2.  Defining FORCE_INDIRECT_CONVERTER (see _XlcEucLoader())
+ *     forces indirect (charset) conversions (e.g. wcstocs()<->cstombs()).
+ * 3.  Using direct converters (e.g. mbstowcs()) decreases conversion
+ *     times by 20-40% (depends on specific converter used).
+ */
+
+
+static int
+sjis_mbstowcs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+
+    XLCd lcd = (XLCd)conv->state;
+
+    int chr_len = 0;
+    int shift_mult = 0;
+    Uint chrcode = 0;
+
+    Uchar ch, ch2;
+    Uint wc_encode = 0;
+    Uint wc_tmp = 0;
+
+    Bool new_char;
+
+    int firstbyte;
+    int length = 0;
+    int num_conv;
+    int unconv_num = 0;
+
+    const char *inbufptr = *from;
+    wchar_t *outbufptr = (wchar_t *) *to;
+    wchar_t *outbuf_base = outbufptr;
+
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+    int codeset_num = XLC_GENERIC(lcd, codeset_num);
+    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);
+
+    if (*from_left > *to_left)
+	*from_left = *to_left;
+
+     for (new_char = True, firstbyte = True; *from_left > 0; (*from_left)--) {
+
+	ch = *inbufptr++;
+
+	if (firstbyte) {
+	    if (ASCII_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    if (isascii(ch)) {
+		length = CS0->length;
+		*outbufptr++ = (wchar_t)ch;
+		continue;
+	    }
+	    else if (iskanji(ch)) {
+		if (KANJI_CODESET >= codeset_num) {
+		    unconv_num++;
+		    (*from_left)--;
+		    continue;
+		}
+		firstbyte = False;
+		length = CS1->length;
+		if (*from_left < length || *to_left < length)
+		    return -1;
+		wc_encode = CS1->wc_encoding;
+		ch2 = *inbufptr;
+		sjis_to_jis(&ch, &ch2);
+		chrcode = ch;
+	    }
+	    else if (iskana(ch)) {
+		if (KANA_CODESET >= codeset_num) {
+		    unconv_num++;
+		    (*from_left)--;
+		    continue;
+		}
+		length = CS2->length;
+		wc_encode = CS2->wc_encoding;
+		chrcode = BIT8OFF(ch);
+	    }
+	    else if (isuserdef(ch)) {
+		if (USERDEF_CODESET >= codeset_num) {
+		    unconv_num++;
+		    (*from_left)--;
+		    continue;
+		}
+		firstbyte = False;
+		length = CS3->length;
+		if (*from_left < length || *to_left < length)
+		    return -1;
+		wc_encode = CS3->wc_encoding;
+		ch2 = *inbufptr;
+		sjis_to_jis(&ch, &ch2);
+		chrcode = ch;
+	    }
+	    else /* unknown */ {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	} else {	     		/* 2nd byte of multibyte char */
+	    if (!VALID_MULTIBYTE((Uchar) *(inbufptr-1))) {
+		unconv_num++;
+		firstbyte = True;
+	    }
+	    chrcode = ch2;
+	}
+
+	if (new_char) {
+	    chr_len = length;
+	    shift_mult = length - 1;
+	    new_char = False;
+	}
+
+	chrcode <<= (wc_shift * shift_mult);
+	shift_mult--;
+	wc_tmp |= chrcode;
+	if (--chr_len == 0) {
+	    wc_tmp |= wc_encode;
+	    *outbufptr++ = wc_tmp;
+
+	    firstbyte = True;
+	    new_char = True;
+	    wc_tmp = (Uint)0;
+	}
+
+    } /* end for */
+
+    *to = (XPointer)outbufptr;
+
+    if ((num_conv = outbufptr - outbuf_base) > 0)
+	(*to_left) -= num_conv;
+
+    return unconv_num;
+}
+
+
+#define byte1		(length == codeset->length - 1)
+#define byte2		(byte1 == 0)
+
+static int
+sjis_wcstombs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    const wchar_t *inbufptr = (const wchar_t *) *from;
+    XPointer outbufptr = *to;
+    XPointer outbuf_base = outbufptr;
+    wchar_t  wch;
+    int length;
+    Uchar tmp;
+    Uchar t1, t2;
+    int num_conv;
+    int unconv_num = 0;
+
+    XLCd lcd = (XLCd)conv->state;
+    CodeSet codeset;
+    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);
+
+    if (*from_left > *to_left)
+	*from_left = *to_left;
+
+    for (; *from_left > 0 ; (*from_left)-- ) {
+
+	wch = *inbufptr++;
+
+	if (!(codeset = wc_codeset(lcd, wch))) {
+	    unconv_num++;
+	    (*from_left)--;
+	    continue;
+	}
+
+	length = codeset->length;
+	wch ^= (wchar_t)codeset->wc_encoding;
+
+	do {
+	    length--;
+	    tmp = wch>>(wchar_t)( (Ulong)length * wc_shift);
+
+	    if (kana)
+		tmp = BIT8ON(tmp);
+
+	    else if (byte1 && (kanji || userdef)) {
+		t1 = BIT8OFF(tmp);
+		continue;
+	    }
+
+	    else if (byte2 && (kanji || userdef)) {
+		t2 = BIT8OFF(tmp);
+		jis_to_sjis(&t1, &t2);
+		*outbufptr++ = (char)t1;
+		tmp = t2;
+	    }
+
+	    *outbufptr++ = (char)tmp;
+	} while (length);
+
+    }	/* end for */
+
+    *to = (XPointer)outbufptr;
+
+    if ((num_conv = (int)(outbufptr - outbuf_base)) > 0)
+	(*to_left) -= num_conv;
+
+    return unconv_num;
+}
+#undef byte1
+#undef byte2
+
+/*
+ * sjis<->jis conversion for widechar kanji (See Note at top of file)
+ */
+static void
+sjis_to_jis(
+    Uchar *p1,
+    Uchar *p2)
+{
+  Uchar c1 = *p1;
+  Uchar c2 = *p2;
+  Uchar adjust = c2 < 0x9f;
+  Uchar rowOffset = c1 < 0xa0 ? 0x70 : 0xb0;
+  Uchar cellOffset = adjust ? (0x1f + (c2 > 0x7f)) : 0x7e;
+
+  *p1 = ((c1 - rowOffset) << 1) - adjust;
+  *p2 -= cellOffset;
+}
+
+static void
+jis_to_sjis(
+    Uchar *p1,
+    Uchar *p2)
+{
+  Uchar c1 = *p1;
+  Uchar c2 = *p2;
+  Uchar rowOffset = c1 < 0x5f ? 0x70 : 0xb0;
+  Uchar cellOffset = c1 % 2 ? 0x1f + (c2 > 0x5f) : 0x7e;
+
+  *p1 = ((Uchar)(c1 + 1) >> 1) + rowOffset;
+  *p2 = c2 + cellOffset;
+}
+
+static CodeSet
+wc_codeset(
+    XLCd lcd,
+    wchar_t wch)
+{
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+#if !defined(__sony_news)  ||  defined(SVR4)
+    int end = XLC_GENERIC(lcd, codeset_num);
+    Ulong widech = (Ulong)(wch & XLC_GENERIC(lcd, wc_encode_mask));
+
+    for (; --end >= 0; codesets++)
+	if ( widech == (*codesets)->wc_encoding )
+	    return *codesets;
+
+    return NULL;
+#else
+    if( iskanji(wch >> 8) )
+	return( codesets[1] );
+    if( iskana(wch & 0xff) )
+	return( codesets[2] );
+    return( codesets[0] );
+#endif
+}
+
+
+static int
+sjis_mbtocs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+    XlcCharSet charset = NULL;
+    int char_size = 0;
+    int unconv_num = 0;
+    const char *src = *from;
+    char *dst = *to;
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+    int codeset_num = XLC_GENERIC(lcd, codeset_num);
+
+    if (iskanji(*src)) {
+	if (KANJI_CODESET >= codeset_num)
+	    return -1;
+	charset = *CS1->charset_list;
+	char_size = charset->char_size;
+
+	if (*from_left >= char_size && *to_left >= char_size) {
+	    *dst++ = *src++;
+	    *dst++ = *src++;
+	    if (!VALID_MULTIBYTE((Uchar) *(src-1))) /* check 2nd byte */
+		unconv_num++;
+	    sjis_to_jis((Uchar *)(dst-2), (Uchar *)(dst-1));
+	} else
+	    return -1;
+    }
+    else if (isuserdef(*src)) {
+	if (USERDEF_CODESET >= codeset_num)
+	    return -1;
+	charset = *CS3->charset_list;
+	char_size = charset->char_size;
+
+	if (*from_left >= char_size && *to_left >= char_size) {
+	    *dst++ = *src++;
+	    *dst++ = *src++;
+	    if (!VALID_MULTIBYTE((Uchar) *(src-1))) /* check 2nd byte */
+		unconv_num++;
+	    sjis_to_jis((Uchar *)(dst-2), (Uchar *)(dst-1));
+	} else
+	    return -1;
+    }
+    else if (isascii(*src)) {
+	if (ASCII_CODESET >= codeset_num)
+	    return -1;
+	charset = *CS0->charset_list;
+	char_size = charset->char_size;
+
+	if (*from_left >= char_size && *to_left >= char_size)
+	    *dst++ = *src++;
+	else
+	    return -1;
+    }
+    else if (iskana(*src)) {
+	if (KANA_CODESET >= codeset_num)
+	    return  -1;
+	charset = *CS2->charset_list;
+	char_size = charset->char_size;
+
+	if (*from_left >= char_size && *to_left >= char_size)
+	    *dst++ = *src++;
+	else
+	   return -1;
+    }
+    else 	/* unknown */
+	return -1;
+
+    *from_left -= char_size;
+    *to_left -= char_size;
+
+    *to = (XPointer) dst;
+    *from = (XPointer) src;
+
+    if (num_args > 0)
+	*((XlcCharSet *) args[0]) = charset;
+
+    return unconv_num;
+}
+
+
+static int
+sjis_mbstocs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    const char *tmp_from;
+    char *tmp_to;
+    int tmp_from_left, tmp_to_left;
+    XlcCharSet charset, tmp_charset;
+    XPointer tmp_args[1];
+    int unconv_num = 0, ret;
+
+/* Determine the charset of the segment and convert one character: */
+
+    tmp_args[0] = (XPointer) &charset; /* charset from sjis_mbtocs() */
+    while
+      ((ret = sjis_mbtocs(conv, from, from_left, to, to_left, tmp_args, 1)) > 0)
+	unconv_num += ret;
+    if ( ret < 0 )
+	return ret;
+
+    tmp_from = *from;
+    tmp_from_left = *from_left;
+    tmp_to_left = *to_left;
+    tmp_to = *to;
+
+/* Convert remainder of the segment: */
+
+    tmp_args[0] = (XPointer) &tmp_charset;
+    while( (ret = sjis_mbtocs(conv, (XPointer *) &tmp_from, &tmp_from_left,
+		     (XPointer *) &tmp_to, &tmp_to_left, tmp_args, 1)) >= 0 ) {
+
+	if (ret > 0) {
+	    unconv_num += ret;
+	    continue;
+	}
+
+	if (tmp_charset != charset)  /* quit on end of segment */
+	    break;
+
+	*from = (XPointer) tmp_from;
+	*from_left = tmp_from_left;
+	*to = (XPointer) tmp_to;
+	*to_left = tmp_to_left;
+    }
+
+    if (num_args > 0)
+	*((XlcCharSet *) args[0]) = charset;
+
+    return unconv_num;
+}
+
+static int
+sjis_wcstocs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd) conv->state;
+    const wchar_t *wcptr = *((const wchar_t **)from);
+    char *bufptr = *((char **) to);
+    wchar_t wch;
+    char *tmpptr;
+    int length;
+    CodeSet codeset;
+    Ulong wc_encoding;
+    int buf_len = *to_left;
+    int wcstr_len = *from_left;
+
+    if (!(codeset = wc_codeset(lcd, *wcptr)))
+	return -1;
+
+    if (wcstr_len < buf_len / codeset->length)
+	buf_len = wcstr_len * codeset->length;
+
+#if !defined(__sony_news)  ||  defined(SVR4)
+    wc_encoding = codeset->wc_encoding;
+
+    for ( ; wcstr_len > 0 && buf_len > 0; wcptr++, wcstr_len--) {
+	wch = *wcptr;
+
+	if ((wch & XLC_GENERIC(lcd, wc_encode_mask)) != wc_encoding)
+	    break;
+
+	length = codeset->length;
+
+	buf_len -= length;
+	bufptr += length;
+	tmpptr = bufptr - 1;
+
+	while (length--) {
+	    *tmpptr-- = kana ? BIT8ON(wch) : BIT8OFF(wch);
+	    wch >>= (wchar_t)XLC_GENERIC(lcd, wc_shift_bits);
+	}
+    }
+#else
+    length = codeset->length;
+    for( ; wcstr_len > 0  &&  buf_len > 0; wcptr++, wcstr_len-- ) {
+	wch = *wcptr;
+	if( codeset != wc_codeset( lcd, wch ) )
+	    break;
+
+	buf_len -= length;
+	if( length == 2 ) {
+	    unsigned short	code;
+
+	    code = sjis2jis( wch & 0xffff );
+	    *bufptr++ = code >> 8;
+	    *bufptr++ = code & 0xff;
+	}
+	else
+	    *bufptr++ = wch & 0xff;
+    }
+#endif
+
+    if (num_args > 0)
+	*((XlcCharSet *) args[0]) = *codeset->charset_list;
+
+    *from_left -= wcptr - (wchar_t *) *from;
+    *from = (XPointer) wcptr;
+
+    *to_left -= bufptr - *to;
+    *to = bufptr;
+
+    return 0;
+}
+
+static CodeSet
+GetCodeSetFromCharSet(
+    XLCd lcd,
+    XlcCharSet charset)
+{
+    CodeSet *codeset = XLC_GENERIC(lcd, codeset_list);
+    XlcCharSet *charset_list;
+    int codeset_num, num_charsets;
+
+    codeset_num = XLC_GENERIC(lcd, codeset_num);
+
+    for ( ; codeset_num-- > 0; codeset++) {
+	num_charsets = (*codeset)->num_charsets;
+	charset_list = (*codeset)->charset_list;
+
+	for ( ; num_charsets-- > 0; charset_list++)
+	    if (*charset_list == charset)
+		return *codeset;
+    }
+
+    return (CodeSet) NULL;
+}
+
+
+static int
+sjis_cstombs(
+    XlcConv conv,
+    char **from,
+    int *from_left,
+    char **to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd) conv->state;
+    const char *csptr = *from;
+    char *bufptr = *to;
+    int csstr_len = *from_left;
+    int buf_len = *to_left;
+    int length;
+    CodeSet codeset;
+    int cvt_length = 0;
+
+    if (num_args < 1)
+	return -1;
+
+    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))
+	return -1;
+
+    csstr_len /= codeset->length;
+    buf_len /= codeset->length;
+    if (csstr_len < buf_len)
+	buf_len = csstr_len;
+
+    cvt_length += buf_len * codeset->length;
+
+    if (bufptr) {
+	while (buf_len--) {
+	    length = codeset->length;
+	    while (length--)
+		*bufptr++ = codeset->length == 1 && codeset->side == XlcGR ?
+		  BIT8ON(*csptr++) : BIT8OFF(*csptr++);
+
+	    if (codeset->length == 2)
+		jis_to_sjis((Uchar *)(bufptr-2), (Uchar *)(bufptr-1));
+	}
+    }
+
+    *from_left -= csptr - *from;
+    *from = (XPointer) csptr;
+
+    if (bufptr)
+	*to += cvt_length;
+    *to_left -= cvt_length;
+
+
+    return 0;
+}
+
+static int
+sjis_cstowcs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd) conv->state;
+    const char *csptr = (const char *) *from;
+    wchar_t *bufptr = (wchar_t *) *to;
+    wchar_t *toptr = (wchar_t *) *to;
+    int csstr_len = *from_left;
+    int buf_len = *to_left;
+    wchar_t wch;
+    int length;
+    Ulong wc_shift_bits = (int)XLC_GENERIC(lcd, wc_shift_bits);
+    CodeSet codeset;
+
+    if (num_args < 1)
+	return -1;
+
+    if (!(codeset = GetCodeSetFromCharSet(lcd, (XlcCharSet) args[0])))
+	return -1;
+
+    csstr_len /= codeset->length;
+    if (csstr_len < buf_len)
+	buf_len = csstr_len;
+
+    *to_left -= buf_len;
+
+    if (bufptr) {
+
+	toptr += buf_len;
+	*to = (XPointer) toptr;
+
+	while (buf_len--) {
+	    wch = (wchar_t) BIT8OFF(*csptr);
+	    csptr++;
+
+	    length = codeset->length - 1;
+	    while (length--) {
+		wch = (wch << wc_shift_bits) | BIT8OFF(*csptr);
+		csptr++;
+	    }
+	    *bufptr++ = wch | codeset->wc_encoding;
+	}
+    }
+
+    *from_left -= csptr - *from;
+    *from = (XPointer) csptr;
+
+    return 0;
+}
+
+
+/*
+ *    Stripped down Direct CT converters for SJIS
+ *
+ */
+
+#define BADCHAR(min_ch, c)  (BIT8OFF(c) < (char)min_ch && BIT8OFF(c) != 0x0 && \
+			     BIT8OFF(c) != '\t' && BIT8OFF(c) != '\n' && \
+			     BIT8OFF(c) != 0x1b)
+
+typedef struct _CTDataRec {
+    int side;
+    int length;
+    char *name;
+    Ulong wc_encoding;
+    char *ct_encoding;
+    int ct_encoding_len;
+    int set_size;
+    Uchar min_ch;
+    Uchar ct_type;
+} CTDataRec, *CTData;
+
+typedef struct _StateRec {
+    CTData GL_charset;
+    CTData GR_charset;
+    CTData charset;
+} StateRec, *State;
+
+#define CT_STD  0
+#define CT_NSTD 1
+#define CT_DIR  2
+#define CT_EXT0 3
+#define CT_EXT1 4
+#define CT_EXT2 5
+#define CT_VER  6
+
+static CTDataRec ctdata[] =
+{
+    { XlcGL,      1, "ISO8859-1:GL",       0, "\033(B"   ,  3, 0, 0, CT_STD  },
+    { XlcGR,      1, "ISO8859-1:GR",       0, "\033-A"   ,  3, 0, 0, CT_STD  },
+    { XlcGL,      1, "JISX0201.1976-0:GL", 0, "\033(J"   ,  3, 0, 0, CT_STD  },
+    { XlcGR,      1, "JISX0201.1976-0:GR", 0, "\033)I"   ,  3, 0, 0, CT_STD  },
+    { XlcGL,      2, "JISX0208.1983-0:GL", 0, "\033$(B"  ,  4, 0, 0, CT_STD  },
+    { XlcGR,      2, "JISX0208.1983-0:GR", 0, "\033$)B"  ,  4, 0, 0, CT_STD  },
+    { XlcGL,      2, "JISX0212.1990-0:GL", 0, "\033$(D"  ,  4, 0, 0, CT_STD  },
+    { XlcGR,      2, "JISX0212.1990-0:GR", 0, "\033$)D"  ,  4, 0, 0, CT_STD  },
+    { XlcUnknown, 0, "Ignore-Ext-Status?", 0, "\033#"    ,  2, 0, 0, CT_VER  },
+    { XlcUnknown, 0, "NonStd-?-OctetChar", 0, "\033%/0"  ,  4, 0, 0, CT_NSTD },
+    { XlcUnknown, 1, "NonStd-1-OctetChar", 0, "\033%/1"  ,  4, 0, 0, CT_NSTD },
+    { XlcUnknown, 2, "NonStd-2-OctetChar", 0, "\033%/2"  ,  4, 0, 0, CT_NSTD },
+    { XlcUnknown, 3, "NonStd-3-OctetChar", 0, "\033%/3"  ,  4, 0, 0, CT_NSTD },
+    { XlcUnknown, 4, "NonStd-4-OctetChar", 0, "\033%/4"  ,  4, 0, 0, CT_NSTD },
+    { XlcUnknown, 0, "Extension-2"       , 0, "\033%/"   ,  3, 0, 0, CT_EXT2 },
+    { XlcUnknown, 0, "Extension-0"       , 0, "\033"     ,  1, 0, 0, CT_EXT0 },
+    { XlcUnknown, 0, "Begin-L-to-R-Text",  0, "\2331]"   ,  3, 0, 0, CT_DIR  },
+    { XlcUnknown, 0, "Begin-R-to-L-Text",  0, "\2332]"   ,  3, 0, 0, CT_DIR  },
+    { XlcUnknown, 0, "End-Of-String",      0, "\233]"    ,  2, 0, 0, CT_DIR  },
+    { XlcUnknown, 0, "Extension-1"       , 0, "\233"     ,  1, 0, 0, CT_EXT1 },
+};
+
+/* Note on above table:  sjis_ctstombs() and sjis_ctstowcs() parser depends on
+ * certain table entries occuring in decreasing string length--
+ *   1.  CT_EXT2 and CT_EXT0 entries must occur after CT_NSTD entries.
+ *   2.  CT_DIR and CT_EXT1 entries must occur after CT_DIR entries.
+ */
+
+static CTData ctdptr[sizeof(ctdata) / sizeof(CTDataRec)];
+static CTData ctd_endp = ctdata + ((sizeof(ctdata) / sizeof(CTDataRec))) - 1;
+
+#define Ascii   0
+#define Kanji   1
+#define Kana    2
+#define Userdef 3
+
+/*
+ * initCTptr(): Set ctptr[] to point at ctdata[], indexed by codeset_num.
+ */
+static void
+initCTptr(
+    XLCd lcd)
+{
+    int num_codesets = XLC_GENERIC(lcd, codeset_num);
+    int num_charsets;
+    int i, j;
+    CodeSet *codesets = XLC_GENERIC(lcd, codeset_list);
+    CodeSet codeset;
+    XlcCharSet charset;
+    CTData ctdp = ctdata;
+
+    ctdptr[Ascii] = &ctdata[0];         /* failsafe */
+
+    for (i = 0; i < num_codesets; i++) {
+
+	codeset = codesets[i];
+	num_charsets = codeset->num_charsets;
+
+	for (j = 0; j < num_charsets; j++) {
+
+	    charset = codeset->charset_list[j];
+
+	    for (ctdp = ctdata; ctdp <= ctd_endp; ctdp++)
+
+		if (! strcmp(ctdp->name, charset->name)) {
+
+		    ctdptr[codeset->cs_num] = ctdp;
+
+		    ctdptr[codeset->cs_num]->wc_encoding = codeset->wc_encoding;
+
+		    ctdptr[codeset->cs_num]->set_size =
+		      charset->set_size;
+
+		    ctdptr[codeset->cs_num]->min_ch =
+		      charset->set_size == 94 &&
+		      (ctdptr[codeset->cs_num]->length > 1 ||
+		      ctdptr[codeset->cs_num]->side == XlcGR) ? 0x21 : 0x20;
+
+		    break;
+		}
+	}
+    }
+}
+
+
+static int
+sjis_mbstocts(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    int ct_len = *to_left;
+    int cs_num;
+    int clen;
+    int unconv_num = 0;
+    int num_conv;
+    const char *inbufptr = *from;
+    char *ctptr = *to;
+    XPointer ct_base = ctptr;
+
+    StateRec ct_state;
+    CTData charset = NULL;
+    XLCd lcd = (XLCd) conv->state;
+    int codeset_num = XLC_GENERIC(lcd, codeset_num);
+
+/* Initial State: */
+
+    ct_state.GL_charset = ctdptr[Ascii];
+    ct_state.GR_charset = NULL;
+
+    if (*from_left > *to_left)
+        *from_left = *to_left;
+
+    for (;*from_left > 0; (*from_left) -= charset->length) {
+
+	if (iskanji(*inbufptr)) {
+	    if (KANJI_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Kanji;
+	    charset = ctdptr[Kanji];
+	    if (!VALID_MULTIBYTE((Uchar) *(inbufptr+1)))
+		unconv_num++;
+	}
+	else if (isuserdef(*inbufptr)) {
+	    if (USERDEF_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Userdef;
+	    charset = ctdptr[Userdef];
+	    if (!VALID_MULTIBYTE((Uchar) *(inbufptr+1)))
+		unconv_num++;
+	}
+	else if (isascii(*inbufptr)) {
+	    if (ASCII_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Ascii;
+	    charset = ctdptr[Ascii];
+	}
+	else if (iskana(*inbufptr)) {
+	    if (KANA_CODESET >= codeset_num) {
+		unconv_num++;
+		(*from_left)--;
+		continue;
+	    }
+	    cs_num = Kana;
+	    charset = ctdptr[Kana];
+	}
+	else { 		 /* unknown */
+	    unconv_num++;
+	    (*from_left)--;
+	    continue;
+	}
+
+	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||
+	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {
+
+	    ct_len -= ctdptr[cs_num]->ct_encoding_len;
+	    if (ct_len < 0) {
+		unconv_num++;
+		break;
+	    }
+
+	    if (ctptr) {
+		strcpy(ctptr, ctdptr[cs_num]->ct_encoding);
+		ctptr += ctdptr[cs_num]->ct_encoding_len;
+	    }
+	}
+
+	clen = charset->length;
+	do {
+	    *ctptr++ = *inbufptr++;
+	} while (--clen);
+
+	if (charset->length >= 2) {
+	    sjis_to_jis((Uchar *)(ctptr-2), (Uchar *)(ctptr-1));
+	    if (BADCHAR(charset->min_ch, *(ctptr-2)) ||
+		  BADCHAR(charset->min_ch, *(ctptr-1))) {
+		unconv_num++;
+		continue;
+	    }
+	}
+	else
+	    if (BADCHAR(charset->min_ch, *(ctptr-1))) {
+		unconv_num++;
+		continue;
+	    }
+
+	if (charset->side == XlcGR)
+	    ct_state.GR_charset = charset;
+	else if (charset->side == XlcGL)
+	    ct_state.GL_charset = charset;
+
+	if (charset->side == XlcGR) {
+	  clen = charset->length;
+	  do {
+	    (*(Uchar *)(ctptr-clen)) = BIT8ON(*(Uchar *)(ctptr-clen));
+	  } while (--clen);
+	}
+    }
+
+    *to = (XPointer)ctptr;
+
+    if ((num_conv = (int)(ctptr - ct_base)) > 0)
+	(*to_left) -= num_conv;
+
+    return unconv_num;
+
+}
+
+
+#define byte1		(length == codeset->length - 1)
+#define byte2		(byte1 == 0)
+
+static int
+sjis_wcstocts(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    int ct_len = *to_left;
+    const wchar_t *inbufptr = (const wchar_t *) *from;
+    char *ctptr = *to;
+    XPointer ct_base = ctptr;
+    wchar_t  wch;
+    int length;
+    Uchar tmp;
+    Uchar t1 = 0;
+    int num_conv;
+
+    StateRec ct_state;
+    XLCd lcd = (XLCd)conv->state;
+    CTData charset;
+    CodeSet codeset;
+    int unconv_num = 0;
+    Ulong wc_shift = XLC_GENERIC(lcd, wc_shift_bits);
+
+/* Initial State: */
+    ct_state.GL_charset = ctdptr[0]; /* Codeset 0 */
+    ct_state.GR_charset = NULL;
+
+    if (*from_left > *to_left)
+	*from_left = *to_left;
+
+    for (; *from_left > 0 ; (*from_left)-- ) {
+
+	wch = *inbufptr++;
+
+        if (!(codeset = wc_codeset(lcd, wch))) {
+            unconv_num++;
+            (*from_left)--;
+            continue;
+        }
+
+	charset = ctdptr[codeset->cs_num];
+
+	length = codeset->length;
+	wch ^= (wchar_t)codeset->wc_encoding;
+
+	if ( (charset->side == XlcGR && charset != ct_state.GR_charset) ||
+	     (charset->side == XlcGL && charset != ct_state.GL_charset) ) {
+
+	    ct_len -= ctdptr[codeset->cs_num]->ct_encoding_len;
+	    if (ct_len < 0) {
+		unconv_num++;
+		break;
+	    }
+
+	    if (ctptr) {
+		strcpy(ctptr, ctdptr[codeset->cs_num]->ct_encoding);
+		ctptr += ctdptr[codeset->cs_num]->ct_encoding_len;
+	    }
+
+	}
+
+	if (charset->side == XlcGR)
+	    ct_state.GR_charset = charset;
+	else if (charset->side == XlcGL)
+	    ct_state.GL_charset = charset;
+
+	do {
+	    length--;
+	    tmp = wch>>(wchar_t)( (Ulong)length * wc_shift);
+
+	    if (kana) {
+		if (BADCHAR(charset->min_ch, (char)tmp)) {
+		    unconv_num++;
+		    break;
+		}
+		*ctptr++ = (char)BIT8ON(tmp);
+	    }
+
+	    else if (byte1 && (kanji || userdef)) {
+		t1 = tmp;
+	    }
+
+	    else if (byte2 && (kanji || userdef)) {
+		if (BADCHAR(charset->min_ch, (char)t1) ||
+		  BADCHAR(charset->min_ch, (char)tmp)) {
+		    unconv_num++;
+		    break;
+		}
+
+		*ctptr++ = (char)BIT8OFF(t1);
+		*ctptr++ = (char)BIT8OFF(tmp);
+	    }
+
+	    else {
+		if (BADCHAR(charset->min_ch, (char)tmp)) {
+		    unconv_num++;
+		    break;
+		}
+		*ctptr++ = (char)tmp;
+	    }
+	} while (length);
+
+    }	/* end for */
+
+    *to = (XPointer)ctptr;
+
+    if ((num_conv = (int)(ctptr - ct_base)) > 0)
+	(*to_left) -= num_conv;
+
+    return unconv_num;
+}
+#undef byte1
+#undef byte2
+
+#define SKIP_I(str)	while (*(str) >= 0x20 && *(str) <=  0x2f) (str)++;
+#define SKIP_P(str)	while (*(str) >= 0x30 && *(str) <=  0x3f) (str)++;
+
+static int
+sjis_ctstombs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    const char *inbufptr =  *from;
+    XPointer outbufptr =  *to;
+    const char *inbuf_base;
+    XPointer outbuf_base = outbufptr;
+    int clen, length;
+    int unconv_num = 0;
+    int num_conv;
+    unsigned int ct_seglen = 0;
+    Uchar ct_type;
+    CTData ctdp = ctdata;	/* default */
+    CTData GL_ctdp = ctdp;	/* GL ctdp save */
+    CTData GR_ctdp = ctdp;	/* GR ctdp save */
+
+    if (*from_left > *to_left)
+	*from_left = *to_left;
+
+    for (length = ctdata[Ascii].length; *from_left > 0 ; (*from_left) -= length)
+    {
+	ct_type = CT_STD;
+	/* change GL/GR charset */
+	if(ctdp->side == XlcGR && isleftside(*inbufptr)){
+	    /* select GL side */
+	    ctdp = GL_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){
+	    /* select GR side */
+	    ctdp = GR_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}
+	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {
+
+	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {
+
+		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))
+		{
+		    inbufptr += ctdp->ct_encoding_len;
+		    (*from_left) -= ctdp->ct_encoding_len;
+		    if( ctdp->length ) {
+			length = ctdp->length;
+			if( *from_left < length ) {
+			    *to = (XPointer)outbufptr;
+			    *to_left -= outbufptr - outbuf_base;
+			    return( unconv_num + *from_left );
+			}
+		    }
+		    ct_type = ctdp->ct_type;
+		    if(ctdp->side == XlcGL){
+			GL_ctdp = ctdp; /* save GL ctdp */
+		    }else{
+			GR_ctdp = ctdp; /* save GR ctdp */
+		    }
+		    break;
+		}
+	    }
+	    if (ctdp > ctd_endp)  	/* failed to match CT sequence */
+		unconv_num++;
+	}
+
+/* The following code insures that non-standard encodings, direction, extension,
+ * and version strings are ignored; subject to change in future.
+ */
+	switch (ct_type) {
+	  case CT_STD:
+	    break;
+	  case CT_EXT2:
+	    inbufptr++;
+	    (*from_left)--;
+	  case CT_NSTD:
+	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;
+	    inbufptr += ct_seglen;
+	    (*from_left) -= ct_seglen;
+	    continue;
+	  case CT_EXT0:
+	    inbuf_base = inbufptr;
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    (*from_left) -= ct_seglen;
+	    continue;
+	  case CT_EXT1:
+	    inbuf_base = inbufptr;
+	    SKIP_P(inbufptr);
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    (*from_left) -= ct_seglen;
+	    continue;
+	  case CT_DIR:
+	    continue;
+	  case CT_VER:
+	    inbufptr += 2;
+	    (*from_left) -= 2;
+	    continue;
+	}
+
+	if (ctdp->side == XlcGL || isrightside (*inbufptr)) {
+	    clen = length;
+	} else {
+	    clen = 1;
+	    *from_left += length - clen;
+	}
+	do {
+	    Uchar mask = (length == 2) ? GL : -1;
+	    *outbufptr++ = *inbufptr++ & mask;
+	} while (--clen);
+
+	if (length >= 2)
+	    jis_to_sjis((Uchar *)(outbufptr-2), (Uchar *)(outbufptr-1));
+    }
+
+    *to = (XPointer)outbufptr;
+
+    if ((num_conv = (int)(outbufptr - outbuf_base)) > 0)
+	(*to_left) -= num_conv;
+
+    return unconv_num;
+}
+
+
+static int
+sjis_ctstowcs(
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XLCd lcd = (XLCd)conv->state;
+    Ulong wc_shift_bits = XLC_GENERIC(lcd, wc_shift_bits);
+    const char *inbufptr = *from;
+    const char *inbuf_base;
+    wchar_t *outbufptr = (wchar_t *) *to;
+    wchar_t *outbuf_base = outbufptr;
+    int clen, length;
+    int num_conv;
+    int unconv_num = 0;
+    unsigned int ct_seglen = 0;
+    Uchar ct_type = 0;
+    int shift_mult;
+    wchar_t wc_tmp;
+    wchar_t wch;
+    Ulong wc_encoding;
+    CTData ctdp = ctdata;
+    CTData GL_ctdp = ctdp;	/* GL ctdp save */
+    CTData GR_ctdp = ctdp;	/* GR ctdp save */
+
+    if (*from_left > *to_left)
+	*from_left = *to_left;
+
+    for (length = ctdata[Ascii].length; *from_left > 0; (*from_left) -= length )
+    {
+	ct_type = CT_STD;
+	/* change GL/GR charset */
+	if(ctdp->side == XlcGR && isleftside(*inbufptr)){
+	    /* select GL side */
+	    ctdp = GL_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}else if(ctdp->side == XlcGL && isrightside(*inbufptr)){
+	    /* select GR side */
+	    ctdp = GR_ctdp;
+	    length = ctdp->length;
+	    ct_type = ctdp->ct_type;
+	}
+	if (*inbufptr == '\033' || *inbufptr == (char)'\233') {
+	    for (ctdp = ctdata; ctdp <= ctd_endp ; ctdp++) {
+
+		if(!strncmp(inbufptr, ctdp->ct_encoding, ctdp->ct_encoding_len))
+		{
+		    inbufptr += ctdp->ct_encoding_len;
+		    (*from_left) -= ctdp->ct_encoding_len;
+		    if( ctdp->length ) {
+			length = ctdp->length;
+			if( *from_left < length ) {
+			    *to = (XPointer)outbufptr;
+			    *to_left -= outbufptr - outbuf_base;
+			    return( unconv_num + *from_left );
+			}
+		    }
+		    ct_type = ctdp->ct_type;
+		    if(ctdp->side == XlcGL){
+			GL_ctdp = ctdp; /* save GL ctdp */
+		    }else{
+			GR_ctdp = ctdp; /* save GR ctdp */
+		    }
+		    break;
+		}
+	    }
+	    if (ctdp > ctd_endp)    	/* failed to match CT sequence */
+		unconv_num++;
+	}
+
+/* The following block of code insures that non-standard encodings, direction,
+ * extension, and version strings are ignored; subject to change in future.
+ */
+	switch (ct_type) {
+	  case CT_STD:
+	    break;
+	  case CT_EXT2:
+	    inbufptr++;
+	    (*from_left)--;
+	  case CT_NSTD:
+	    ct_seglen = (BIT8OFF(*inbufptr) << 7) + BIT8OFF(*(inbufptr+1)) + 2;
+	    inbufptr += ct_seglen;
+	    (*from_left) -= ct_seglen;
+	    continue;
+	  case CT_EXT0:
+	    inbuf_base = inbufptr;
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    (*from_left) -= ct_seglen;
+	    continue;
+	  case CT_EXT1:
+	    inbuf_base = inbufptr;
+	    SKIP_P(inbufptr);
+	    SKIP_I(inbufptr);
+	    inbufptr++;
+	    ct_seglen = (unsigned)(inbufptr - inbuf_base);
+	    (*from_left) -= ct_seglen;
+	    continue;
+	  case CT_DIR:
+	    continue;
+	  case CT_VER:
+	    inbufptr += 2;
+	    (*from_left) -= 2;
+	    continue;
+	}
+#if !defined(__sony_news)  ||  defined(SVR4)
+	if (ctdp->side == XlcGL || isrightside (*inbufptr)) {
+	    clen = length;
+	    wc_encoding = ctdp->wc_encoding;
+	} else {
+	    clen = 1;
+	    *from_left += length - clen;
+	    wc_encoding = ctdptr[Ascii]->wc_encoding;
+	}
+	shift_mult = clen - 1;
+	wch = (wchar_t)0;
+
+	do {
+	    wc_tmp = BIT8OFF(*inbufptr++) << (wc_shift_bits * shift_mult);
+	    wch |= wc_tmp;
+	    shift_mult--;
+	} while (--clen);
+	*outbufptr++ = wch | wc_encoding;
+#else
+	if( length == 1 )
+	    *outbufptr++ = (unsigned char)*inbufptr++;
+	else if( length == 2 ) {
+	    unsigned short	code;
+	    code = (*inbufptr << 8) | *(inbufptr+1);
+	    *outbufptr++ = jis2sjis( code );
+	    inbufptr += 2;
+	}
+#endif
+    }
+    *to = (XPointer)outbufptr;
+
+    if ((num_conv = (int)(outbufptr - outbuf_base)) > 0)
+	(*to_left) -= num_conv ;
+
+    return unconv_num;
+
+}
+#undef BADCHAR
+
+static void
+close_converter(
+    XlcConv conv)
+{
+	Xfree((char *) conv);
+}
+
+
+static XlcConv
+create_conv(
+    XLCd lcd,
+    XlcConvMethods methods)
+{
+    XlcConv conv;
+
+    conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));
+    if (conv == NULL)
+	return (XlcConv) NULL;
+
+    conv->methods = methods;
+    conv->state = (XPointer) lcd;
+    return conv;
+}
+
+
+enum { MBSTOCS, WCSTOCS, MBTOCS, CSTOMBS, CSTOWCS, MBSTOWCS, WCSTOMBS,
+       WCSTOCTS, MBSTOCTS, CTSTOMBS, CTSTOWCS };
+
+static XlcConvMethodsRec conv_methods[] = {
+    {close_converter, sjis_mbstocs,  NULL },
+    {close_converter, sjis_wcstocs,  NULL },
+    {close_converter, sjis_mbtocs,   NULL },
+    {close_converter, sjis_cstombs,  NULL },
+    {close_converter, sjis_cstowcs,  NULL },
+    {close_converter, sjis_mbstowcs, NULL },
+    {close_converter, sjis_wcstombs, NULL },
+    {close_converter, sjis_wcstocts, NULL },
+    {close_converter, sjis_mbstocts, NULL },
+    {close_converter, sjis_ctstombs, NULL },
+    {close_converter, sjis_ctstowcs, NULL },
+};
+
+
+static XlcConv
+open_mbstocs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBSTOCS]);
+}
+
+static XlcConv
+open_wcstocs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[WCSTOCS]);
+}
+
+static XlcConv
+open_mbtocs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBTOCS]);
+}
+
+static XlcConv
+open_cstombs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CSTOMBS]);
+}
+
+static XlcConv
+open_cstowcs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CSTOWCS]);
+}
+
+static XlcConv
+open_mbstowcs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBSTOWCS]);
+}
+
+static XlcConv
+open_wcstombs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[WCSTOMBS]);
+}
+
+static XlcConv
+open_wcstocts(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[WCSTOCTS]);
+}
+
+static XlcConv
+open_mbstocts(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[MBSTOCTS]);
+}
+
+static XlcConv
+open_ctstombs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CTSTOMBS]);
+}
+
+static XlcConv
+open_ctstowcs(
+    XLCd from_lcd,
+    const char *from_type,
+    XLCd to_lcd,
+    const char *to_type)
+{
+    return create_conv(from_lcd, &conv_methods[CTSTOWCS]);
+}
+
+XLCd
+_XlcSjisLoader(
+    const char *name)
+{
+    XLCd lcd;
+
+    lcd = _XlcCreateLC(name, _XlcGenericMethods);
+    if (lcd == NULL)
+	return lcd;
+
+    if (!XLC_PUBLIC_PART(lcd)->codeset ||
+	(_XlcCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "SJIS"))) {
+	_XlcDestroyLC(lcd);
+	return (XLCd) NULL;
+    }
+
+    initCTptr(lcd);
+
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_mbstocs);
+    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstocs);
+    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_cstombs);
+    _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_cstowcs);
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_mbtocs);
+
+#ifndef FORCE_INDIRECT_CONVERTER
+    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNMultiByte, open_ctstombs);
+    _XlcSetConverter(lcd, XlcNCompoundText, lcd, XlcNWideChar, open_ctstowcs);
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCompoundText, open_mbstocts);
+    _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_mbstowcs);
+    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCompoundText, open_wcstocts);
+    _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_wcstombs);
+#endif
+
+    _XlcAddUtf8Converters(lcd);
+
+    return lcd;
+}
+
+#else
+typedef int dummy;
+#endif /* X_LOCALE */
diff --git a/libX11/modules/om/Makefile.am b/libX11/modules/om/Makefile.am
index cb22f5a42..24f4c06a2 100644
--- a/libX11/modules/om/Makefile.am
+++ b/libX11/modules/om/Makefile.am
@@ -1 +1 @@
-SUBDIRS=generic

+SUBDIRS=generic
diff --git a/libX11/modules/om/generic/Makefile.am b/libX11/modules/om/generic/Makefile.am
index 435a0aa66..4a10b38c4 100644
--- a/libX11/modules/om/generic/Makefile.am
+++ b/libX11/modules/om/generic/Makefile.am
@@ -1,42 +1,42 @@
-AM_CPPFLAGS= \

-	-I$(top_srcdir)/include \

-	-I$(top_srcdir)/include/X11 \

-	-I$(top_builddir)/include \

-	-I$(top_builddir)/include/X11 \

-	-I$(top_srcdir)/src/xcms \

-	-I$(top_srcdir)/src/xkb \

-	-I$(top_srcdir)/src/xlibi18n \

-	-I$(top_srcdir)/src \

-	-D_BSD_SOURCE

-

-AM_CFLAGS= \

-	$(X11_CFLAGS) \

-	$(BIGFONT_CFLAGS) \

-	$(MALLOC_ZERO_CFLAGS) \

-	$(CWARNFLAGS)

-

-if XLIB_LOADABLE_I18N

-

-commonlibdir = $(X11_LOCALELIBDIR)/common

-commonlib_LTLIBRARIES=xomGeneric.la

-xomGeneric_la_LDFLAGS = -module -version-number 2:0:0

-xomGeneric_la_LIBADD = $(I18N_MODULE_LIBS)

-

-else

-

-noinst_LTLIBRARIES = libxomGeneric.la

-

-endif

-

-

-xomGeneric_la_SOURCES = \

-	omDefault.c \

-	omGeneric.c \

-	omImText.c \

-	omText.c \

-	omTextEsc.c \

-	omTextExt.c \

-	omTextPer.c \

-	omXChar.c

-

-libxomGeneric_la_SOURCES = $(xomGeneric_la_SOURCES)

+AM_CPPFLAGS= \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/include/X11 \
+	-I$(top_builddir)/include \
+	-I$(top_builddir)/include/X11 \
+	-I$(top_srcdir)/src/xcms \
+	-I$(top_srcdir)/src/xkb \
+	-I$(top_srcdir)/src/xlibi18n \
+	-I$(top_srcdir)/src \
+	-D_BSD_SOURCE
+
+AM_CFLAGS= \
+	$(X11_CFLAGS) \
+	$(BIGFONT_CFLAGS) \
+	$(MALLOC_ZERO_CFLAGS) \
+	$(CWARNFLAGS)
+
+if XLIB_LOADABLE_I18N
+
+commonlibdir = $(X11_LOCALELIBDIR)/common
+commonlib_LTLIBRARIES=xomGeneric.la
+xomGeneric_la_LDFLAGS = -module -version-number 2:0:0
+xomGeneric_la_LIBADD = $(I18N_MODULE_LIBS)
+
+else
+
+noinst_LTLIBRARIES = libxomGeneric.la
+
+endif
+
+
+xomGeneric_la_SOURCES = \
+	omDefault.c \
+	omGeneric.c \
+	omImText.c \
+	omText.c \
+	omTextEsc.c \
+	omTextExt.c \
+	omTextPer.c \
+	omXChar.c
+
+libxomGeneric_la_SOURCES = $(xomGeneric_la_SOURCES)
diff --git a/libX11/modules/om/generic/omDefault.c b/libX11/modules/om/generic/omDefault.c
index 3f867ba65..322690fa0 100644
--- a/libX11/modules/om/generic/omDefault.c
+++ b/libX11/modules/om/generic/omDefault.c
@@ -1,449 +1,449 @@
-/*

- * Copyright 1992, 1993 by TOSHIBA Corp.

- *

- * Permission to use, copy, modify, and distribute this software and its

- * documentation for any purpose and without fee is hereby granted, provided

- * that the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of TOSHIBA not be used in advertising

- * or publicity pertaining to distribution of the software without specific,

- * written prior permission. TOSHIBA make no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- *

- * Author: Katsuhisa Yano	TOSHIBA Corp.

- *			   	mopi@osa.ilab.toshiba.co.jp

- */

-/*

- *  (c) Copyright 1995 FUJITSU LIMITED

- *  This is source code modified by FUJITSU LIMITED under the Joint

- *  Development Agreement for the CDE/Motif PST.

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XomGeneric.h"

-#include <X11/Xos.h>

-#include <X11/Xatom.h>

-#include <stdio.h>

-

-#define DefineLocalBuf		char local_buf[BUFSIZ]

-#define AllocLocalBuf(length)	(length > BUFSIZ ? (char *)Xmalloc(length) : local_buf)

-#define FreeLocalBuf(ptr)	if (ptr != local_buf) Xfree(ptr)

-

-static Bool

-wcs_to_mbs(

-    XOC oc,

-    char *to,

-    _Xconst wchar_t *from,

-    int length)

-{

-    XlcConv conv;

-    int to_left, ret;

-

-    conv = _XomInitConverter(oc, XOMWideChar);

-    if (conv == NULL)

-	return False;

-

-    to_left = length;

-    ret = _XlcConvert(conv, (XPointer *) &from, &length, (XPointer *) &to,

-		      &to_left, NULL, 0);

-    if (ret != 0 || length > 0)

-	return False;

-

-    return True;

-}

-

-static Bool

-utf8_to_mbs(

-    XOC oc,

-    char *to,

-    _Xconst char *from,

-    int length)

-{

-    XlcConv conv;

-    int to_left, ret;

-

-    conv = _XomInitConverter(oc, XOMUtf8String);

-    if (conv == NULL)

-	return False;

-

-    to_left = length;

-    ret = _XlcConvert(conv, (XPointer *) &from, &length, (XPointer *) &to,

-		      &to_left, NULL, 0);

-    if (ret != 0 || length > 0)

-	return False;

-

-    return True;

-}

-

-int

-_XmbDefaultTextEscapement(XOC oc, _Xconst char *text, int length)

-{

-    return XTextWidth(*oc->core.font_info.font_struct_list, text, length);

-}

-

-int

-_XwcDefaultTextEscapement(XOC oc, _Xconst wchar_t *text, int length)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    int ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (wcs_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultTextEscapement(oc, buf, length);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-int

-_Xutf8DefaultTextEscapement(XOC oc, _Xconst char *text, int length)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    int ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (utf8_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultTextEscapement(oc, buf, length);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-int

-_XmbDefaultTextExtents(XOC oc, _Xconst char *text, int length,

-		       XRectangle *overall_ink, XRectangle *overall_logical)

-{

-    int direction, logical_ascent, logical_descent;

-    XCharStruct overall;

-

-    XTextExtents(*oc->core.font_info.font_struct_list, text, length, &direction,

-		 &logical_ascent, &logical_descent, &overall);

-

-    if (overall_ink) {

-	overall_ink->x = overall.lbearing;

-	overall_ink->y = -(overall.ascent);

-	overall_ink->width = overall.rbearing - overall.lbearing;

-	overall_ink->height = overall.ascent + overall.descent;

-    }

-

-    if (overall_logical) {

-	overall_logical->x = 0;

-        overall_logical->y = -(logical_ascent);

-	overall_logical->width = overall.width;

-        overall_logical->height = logical_ascent + logical_descent;

-    }

-

-    return overall.width;

-}

-

-int

-_XwcDefaultTextExtents(XOC oc, _Xconst wchar_t *text, int length,

-		       XRectangle *overall_ink, XRectangle *overall_logical)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    int ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (wcs_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultTextExtents(oc, buf, length, overall_ink, overall_logical);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-int

-_Xutf8DefaultTextExtents(XOC oc, _Xconst char *text, int length,

-			 XRectangle *overall_ink, XRectangle *overall_logical)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    int ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (utf8_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultTextExtents(oc, buf, length, overall_ink, overall_logical);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-Status

-_XmbDefaultTextPerCharExtents(XOC oc, _Xconst char *text, int length,

-			      XRectangle *ink_buf, XRectangle *logical_buf,

-			      int buf_size, int *num_chars,

-			      XRectangle *overall_ink,

-			      XRectangle *overall_logical)

-{

-    XFontStruct *font = *oc->core.font_info.font_struct_list;

-    XCharStruct *def, *cs, overall;

-    Bool first = True;

-

-    if (buf_size < length)

-	return 0;

-

-    bzero((char *) &overall, sizeof(XCharStruct));

-    *num_chars = 0;

-

-    CI_GET_DEFAULT_INFO_1D(font, def)

-

-    while (length-- > 0) {

-	CI_GET_CHAR_INFO_1D(font, *text, def, cs)

-	text++;

-	if (cs == NULL)

-	    continue;

-

-	ink_buf->x = overall.width + cs->lbearing;

-	ink_buf->y = -(cs->ascent);

-	ink_buf->width = cs->rbearing - cs->lbearing;

-	ink_buf->height = cs->ascent + cs->descent;

-	ink_buf++;

-

-	logical_buf->x = overall.width;

-	logical_buf->y = -(font->ascent);

-	logical_buf->width = cs->width;

-	logical_buf->height = font->ascent + font->descent;

-	logical_buf++;

-

-	if (first) {

-	    overall = *cs;

-	    first = False;

-	} else {

-	    overall.ascent = max(overall.ascent, cs->ascent);

-	    overall.descent = max(overall.descent, cs->descent);

-	    overall.lbearing = min(overall.lbearing, overall.width +

-				   cs->lbearing);

-	    overall.rbearing = max(overall.rbearing, overall.width +

-				   cs->rbearing);

-	    overall.width += cs->width;

-	}

-

-	(*num_chars)++;

-    }

-

-    if (overall_ink) {

-	overall_ink->x = overall.lbearing;

-	overall_ink->y = -(overall.ascent);

-	overall_ink->width = overall.rbearing - overall.lbearing;

-	overall_ink->height = overall.ascent + overall.descent;

-    }

-

-    if (overall_logical) {

-	overall_logical->x = 0;

-	overall_logical->y = -(font->ascent);

-	overall_logical->width = overall.width;

-	overall_logical->height = font->ascent + font->descent;

-    }

-

-    return 1;

-}

-

-Status

-_XwcDefaultTextPerCharExtents(XOC oc, _Xconst wchar_t *text, int length,

-			      XRectangle *ink_buf, XRectangle *logical_buf,

-			      int buf_size, int *num_chars,

-			      XRectangle *overall_ink,

-			      XRectangle *overall_logical)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    Status ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (wcs_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultTextPerCharExtents(oc, buf, length, ink_buf, logical_buf,

-					buf_size, num_chars, overall_ink,

-					overall_logical);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-Status

-_Xutf8DefaultTextPerCharExtents(XOC oc, _Xconst char *text, int length,

-				XRectangle *ink_buf, XRectangle *logical_buf,

-				int buf_size, int *num_chars,

-				XRectangle *overall_ink,

-				XRectangle *overall_logical)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    Status ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (utf8_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultTextPerCharExtents(oc, buf, length, ink_buf, logical_buf,

-					buf_size, num_chars, overall_ink,

-					overall_logical);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-int

-_XmbDefaultDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,

-		      _Xconst char *text, int length)

-{

-    XFontStruct *font = *oc->core.font_info.font_struct_list;

-

-    XSetFont(dpy, gc, font->fid);

-    XDrawString(dpy, d, gc, x, y, text, length);

-

-    return XTextWidth(font, text, length);

-}

-

-int

-_XwcDefaultDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,

-		      _Xconst wchar_t *text, int length)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    int ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (wcs_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultDrawString(dpy, d, oc, gc, x, y, buf, length);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-int

-_Xutf8DefaultDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,

-			_Xconst char *text, int length)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-    int ret;

-

-    if (buf == NULL)

-	return 0;

-

-    if (utf8_to_mbs(oc, buf, text, length) == False) {

-	ret = 0;

-	goto err;

-    }

-

-    ret = _XmbDefaultDrawString(dpy, d, oc, gc, x, y, buf, length);

-

-err:

-    FreeLocalBuf(buf);

-

-    return ret;

-}

-

-void

-_XmbDefaultDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,

-			   int y, _Xconst char *text, int length)

-{

-    XSetFont(dpy, gc, (*oc->core.font_info.font_struct_list)->fid);

-    XDrawImageString(dpy, d, gc, x, y, text, length);

-}

-

-void

-_XwcDefaultDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,

-			   int y, _Xconst wchar_t *text, int length)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-

-    if (buf == NULL)

-	return;

-

-    if (wcs_to_mbs(oc, buf, text, length) == False)

-	goto err;

-

-    _XmbDefaultDrawImageString(dpy, d, oc, gc, x, y, buf, length);

-

-err:

-    FreeLocalBuf(buf);

-}

-

-void

-_Xutf8DefaultDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,

-			     int y, _Xconst char *text, int length)

-{

-    DefineLocalBuf;

-    char *buf = AllocLocalBuf(length);

-

-    if (buf == NULL)

-	return;

-

-    if (utf8_to_mbs(oc, buf, text, length) == False)

-	goto err;

-

-    _XmbDefaultDrawImageString(dpy, d, oc, gc, x, y, buf, length);

-

-err:

-    FreeLocalBuf(buf);

-}

+/*
+ * Copyright 1992, 1993 by TOSHIBA Corp.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of TOSHIBA not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission. TOSHIBA make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * Author: Katsuhisa Yano	TOSHIBA Corp.
+ *			   	mopi@osa.ilab.toshiba.co.jp
+ */
+/*
+ *  (c) Copyright 1995 FUJITSU LIMITED
+ *  This is source code modified by FUJITSU LIMITED under the Joint
+ *  Development Agreement for the CDE/Motif PST.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XomGeneric.h"
+#include <X11/Xos.h>
+#include <X11/Xatom.h>
+#include <stdio.h>
+
+#define DefineLocalBuf		char local_buf[BUFSIZ]
+#define AllocLocalBuf(length)	(length > BUFSIZ ? (char *)Xmalloc(length) : local_buf)
+#define FreeLocalBuf(ptr)	if (ptr != local_buf) Xfree(ptr)
+
+static Bool
+wcs_to_mbs(
+    XOC oc,
+    char *to,
+    _Xconst wchar_t *from,
+    int length)
+{
+    XlcConv conv;
+    int to_left, ret;
+
+    conv = _XomInitConverter(oc, XOMWideChar);
+    if (conv == NULL)
+	return False;
+
+    to_left = length;
+    ret = _XlcConvert(conv, (XPointer *) &from, &length, (XPointer *) &to,
+		      &to_left, NULL, 0);
+    if (ret != 0 || length > 0)
+	return False;
+
+    return True;
+}
+
+static Bool
+utf8_to_mbs(
+    XOC oc,
+    char *to,
+    _Xconst char *from,
+    int length)
+{
+    XlcConv conv;
+    int to_left, ret;
+
+    conv = _XomInitConverter(oc, XOMUtf8String);
+    if (conv == NULL)
+	return False;
+
+    to_left = length;
+    ret = _XlcConvert(conv, (XPointer *) &from, &length, (XPointer *) &to,
+		      &to_left, NULL, 0);
+    if (ret != 0 || length > 0)
+	return False;
+
+    return True;
+}
+
+int
+_XmbDefaultTextEscapement(XOC oc, _Xconst char *text, int length)
+{
+    return XTextWidth(*oc->core.font_info.font_struct_list, text, length);
+}
+
+int
+_XwcDefaultTextEscapement(XOC oc, _Xconst wchar_t *text, int length)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    int ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (wcs_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultTextEscapement(oc, buf, length);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+int
+_Xutf8DefaultTextEscapement(XOC oc, _Xconst char *text, int length)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    int ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (utf8_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultTextEscapement(oc, buf, length);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+int
+_XmbDefaultTextExtents(XOC oc, _Xconst char *text, int length,
+		       XRectangle *overall_ink, XRectangle *overall_logical)
+{
+    int direction, logical_ascent, logical_descent;
+    XCharStruct overall;
+
+    XTextExtents(*oc->core.font_info.font_struct_list, text, length, &direction,
+		 &logical_ascent, &logical_descent, &overall);
+
+    if (overall_ink) {
+	overall_ink->x = overall.lbearing;
+	overall_ink->y = -(overall.ascent);
+	overall_ink->width = overall.rbearing - overall.lbearing;
+	overall_ink->height = overall.ascent + overall.descent;
+    }
+
+    if (overall_logical) {
+	overall_logical->x = 0;
+        overall_logical->y = -(logical_ascent);
+	overall_logical->width = overall.width;
+        overall_logical->height = logical_ascent + logical_descent;
+    }
+
+    return overall.width;
+}
+
+int
+_XwcDefaultTextExtents(XOC oc, _Xconst wchar_t *text, int length,
+		       XRectangle *overall_ink, XRectangle *overall_logical)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    int ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (wcs_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultTextExtents(oc, buf, length, overall_ink, overall_logical);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+int
+_Xutf8DefaultTextExtents(XOC oc, _Xconst char *text, int length,
+			 XRectangle *overall_ink, XRectangle *overall_logical)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    int ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (utf8_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultTextExtents(oc, buf, length, overall_ink, overall_logical);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+Status
+_XmbDefaultTextPerCharExtents(XOC oc, _Xconst char *text, int length,
+			      XRectangle *ink_buf, XRectangle *logical_buf,
+			      int buf_size, int *num_chars,
+			      XRectangle *overall_ink,
+			      XRectangle *overall_logical)
+{
+    XFontStruct *font = *oc->core.font_info.font_struct_list;
+    XCharStruct *def, *cs, overall;
+    Bool first = True;
+
+    if (buf_size < length)
+	return 0;
+
+    bzero((char *) &overall, sizeof(XCharStruct));
+    *num_chars = 0;
+
+    CI_GET_DEFAULT_INFO_1D(font, def)
+
+    while (length-- > 0) {
+	CI_GET_CHAR_INFO_1D(font, *text, def, cs)
+	text++;
+	if (cs == NULL)
+	    continue;
+
+	ink_buf->x = overall.width + cs->lbearing;
+	ink_buf->y = -(cs->ascent);
+	ink_buf->width = cs->rbearing - cs->lbearing;
+	ink_buf->height = cs->ascent + cs->descent;
+	ink_buf++;
+
+	logical_buf->x = overall.width;
+	logical_buf->y = -(font->ascent);
+	logical_buf->width = cs->width;
+	logical_buf->height = font->ascent + font->descent;
+	logical_buf++;
+
+	if (first) {
+	    overall = *cs;
+	    first = False;
+	} else {
+	    overall.ascent = max(overall.ascent, cs->ascent);
+	    overall.descent = max(overall.descent, cs->descent);
+	    overall.lbearing = min(overall.lbearing, overall.width +
+				   cs->lbearing);
+	    overall.rbearing = max(overall.rbearing, overall.width +
+				   cs->rbearing);
+	    overall.width += cs->width;
+	}
+
+	(*num_chars)++;
+    }
+
+    if (overall_ink) {
+	overall_ink->x = overall.lbearing;
+	overall_ink->y = -(overall.ascent);
+	overall_ink->width = overall.rbearing - overall.lbearing;
+	overall_ink->height = overall.ascent + overall.descent;
+    }
+
+    if (overall_logical) {
+	overall_logical->x = 0;
+	overall_logical->y = -(font->ascent);
+	overall_logical->width = overall.width;
+	overall_logical->height = font->ascent + font->descent;
+    }
+
+    return 1;
+}
+
+Status
+_XwcDefaultTextPerCharExtents(XOC oc, _Xconst wchar_t *text, int length,
+			      XRectangle *ink_buf, XRectangle *logical_buf,
+			      int buf_size, int *num_chars,
+			      XRectangle *overall_ink,
+			      XRectangle *overall_logical)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    Status ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (wcs_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultTextPerCharExtents(oc, buf, length, ink_buf, logical_buf,
+					buf_size, num_chars, overall_ink,
+					overall_logical);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+Status
+_Xutf8DefaultTextPerCharExtents(XOC oc, _Xconst char *text, int length,
+				XRectangle *ink_buf, XRectangle *logical_buf,
+				int buf_size, int *num_chars,
+				XRectangle *overall_ink,
+				XRectangle *overall_logical)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    Status ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (utf8_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultTextPerCharExtents(oc, buf, length, ink_buf, logical_buf,
+					buf_size, num_chars, overall_ink,
+					overall_logical);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+int
+_XmbDefaultDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,
+		      _Xconst char *text, int length)
+{
+    XFontStruct *font = *oc->core.font_info.font_struct_list;
+
+    XSetFont(dpy, gc, font->fid);
+    XDrawString(dpy, d, gc, x, y, text, length);
+
+    return XTextWidth(font, text, length);
+}
+
+int
+_XwcDefaultDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,
+		      _Xconst wchar_t *text, int length)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    int ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (wcs_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultDrawString(dpy, d, oc, gc, x, y, buf, length);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+int
+_Xutf8DefaultDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,
+			_Xconst char *text, int length)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+    int ret;
+
+    if (buf == NULL)
+	return 0;
+
+    if (utf8_to_mbs(oc, buf, text, length) == False) {
+	ret = 0;
+	goto err;
+    }
+
+    ret = _XmbDefaultDrawString(dpy, d, oc, gc, x, y, buf, length);
+
+err:
+    FreeLocalBuf(buf);
+
+    return ret;
+}
+
+void
+_XmbDefaultDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,
+			   int y, _Xconst char *text, int length)
+{
+    XSetFont(dpy, gc, (*oc->core.font_info.font_struct_list)->fid);
+    XDrawImageString(dpy, d, gc, x, y, text, length);
+}
+
+void
+_XwcDefaultDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,
+			   int y, _Xconst wchar_t *text, int length)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+
+    if (buf == NULL)
+	return;
+
+    if (wcs_to_mbs(oc, buf, text, length) == False)
+	goto err;
+
+    _XmbDefaultDrawImageString(dpy, d, oc, gc, x, y, buf, length);
+
+err:
+    FreeLocalBuf(buf);
+}
+
+void
+_Xutf8DefaultDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,
+			     int y, _Xconst char *text, int length)
+{
+    DefineLocalBuf;
+    char *buf = AllocLocalBuf(length);
+
+    if (buf == NULL)
+	return;
+
+    if (utf8_to_mbs(oc, buf, text, length) == False)
+	goto err;
+
+    _XmbDefaultDrawImageString(dpy, d, oc, gc, x, y, buf, length);
+
+err:
+    FreeLocalBuf(buf);
+}
diff --git a/libX11/modules/om/generic/omImText.c b/libX11/modules/om/generic/omImText.c
index 68086ff76..1bc08bc25 100644
--- a/libX11/modules/om/generic/omImText.c
+++ b/libX11/modules/om/generic/omImText.c
@@ -1,90 +1,90 @@
-/*

- * Copyright 1992, 1993 by TOSHIBA Corp.

- *

- * Permission to use, copy, modify, and distribute this software and its

- * documentation for any purpose and without fee is hereby granted, provided

- * that the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of TOSHIBA not be used in advertising

- * or publicity pertaining to distribution of the software without specific,

- * written prior permission. TOSHIBA make no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- *

- * Author: Katsuhisa Yano	TOSHIBA Corp.

- *			   	mopi@osa.ilab.toshiba.co.jp

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XomGeneric.h"

-

-#if 0

-extern int _XomGenericTextExtents(), _XomGenericDrawString();

-#endif

-

-#define GET_VALUE_MASK	(GCFunction | GCForeground | GCBackground | GCFillStyle)

-#define SET_VALUE_MASK	(GCFunction | GCForeground | GCFillStyle)

-

-static void

-_XomGenericDrawImageString(

-    Display *dpy,

-    Drawable d,

-    XOC oc,

-    GC gc,

-    int x, int y,

-    XOMTextType type,

-    XPointer text,

-    int length)

-{

-    XGCValues values;

-    XRectangle extent;

-

-    XGetGCValues(dpy, gc, GET_VALUE_MASK, &values);

-

-    XSetFunction(dpy, gc, GXcopy);

-    XSetForeground(dpy, gc, values.background);

-    XSetFillStyle(dpy, gc, FillSolid);

-

-    _XomGenericTextExtents(oc, type, text, length, 0, &extent);

-    XFillRectangle(dpy, d, gc, x + extent.x, y + extent.y, extent.width,

-		   extent.height);

-

-    XChangeGC(dpy, gc, SET_VALUE_MASK, &values);

-

-    _XomGenericDrawString(dpy, d, oc, gc, x, y, type, text, length);

-}

-

-void

-_XmbGenericDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,

-			   int y, _Xconst char *text, int length)

-{

-    _XomGenericDrawImageString(dpy, d, oc, gc, x, y, XOMMultiByte,

-			       (XPointer) text, length);

-}

-

-void

-_XwcGenericDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,

-			   int y, _Xconst wchar_t *text, int length)

-{

-    _XomGenericDrawImageString(dpy, d, oc, gc, x, y, XOMWideChar,

-			       (XPointer) text, length);

-}

-

-void

-_Xutf8GenericDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,

-			     int y, _Xconst char *text, int length)

-{

-    _XomGenericDrawImageString(dpy, d, oc, gc, x, y, XOMUtf8String,

-			       (XPointer) text, length);

-}

+/*
+ * Copyright 1992, 1993 by TOSHIBA Corp.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of TOSHIBA not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission. TOSHIBA make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * Author: Katsuhisa Yano	TOSHIBA Corp.
+ *			   	mopi@osa.ilab.toshiba.co.jp
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XomGeneric.h"
+
+#if 0
+extern int _XomGenericTextExtents(), _XomGenericDrawString();
+#endif
+
+#define GET_VALUE_MASK	(GCFunction | GCForeground | GCBackground | GCFillStyle)
+#define SET_VALUE_MASK	(GCFunction | GCForeground | GCFillStyle)
+
+static void
+_XomGenericDrawImageString(
+    Display *dpy,
+    Drawable d,
+    XOC oc,
+    GC gc,
+    int x, int y,
+    XOMTextType type,
+    XPointer text,
+    int length)
+{
+    XGCValues values;
+    XRectangle extent;
+
+    XGetGCValues(dpy, gc, GET_VALUE_MASK, &values);
+
+    XSetFunction(dpy, gc, GXcopy);
+    XSetForeground(dpy, gc, values.background);
+    XSetFillStyle(dpy, gc, FillSolid);
+
+    _XomGenericTextExtents(oc, type, text, length, 0, &extent);
+    XFillRectangle(dpy, d, gc, x + extent.x, y + extent.y, extent.width,
+		   extent.height);
+
+    XChangeGC(dpy, gc, SET_VALUE_MASK, &values);
+
+    _XomGenericDrawString(dpy, d, oc, gc, x, y, type, text, length);
+}
+
+void
+_XmbGenericDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,
+			   int y, _Xconst char *text, int length)
+{
+    _XomGenericDrawImageString(dpy, d, oc, gc, x, y, XOMMultiByte,
+			       (XPointer) text, length);
+}
+
+void
+_XwcGenericDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,
+			   int y, _Xconst wchar_t *text, int length)
+{
+    _XomGenericDrawImageString(dpy, d, oc, gc, x, y, XOMWideChar,
+			       (XPointer) text, length);
+}
+
+void
+_Xutf8GenericDrawImageString(Display *dpy, Drawable d, XOC oc, GC gc, int x,
+			     int y, _Xconst char *text, int length)
+{
+    _XomGenericDrawImageString(dpy, d, oc, gc, x, y, XOMUtf8String,
+			       (XPointer) text, length);
+}
diff --git a/libX11/modules/om/generic/omText.c b/libX11/modules/om/generic/omText.c
index fd957d491..bfceca96e 100644
--- a/libX11/modules/om/generic/omText.c
+++ b/libX11/modules/om/generic/omText.c
@@ -1,370 +1,370 @@
-/*

- * Copyright 1992, 1993 by TOSHIBA Corp.

- *

- * Permission to use, copy, modify, and distribute this software and its

- * documentation for any purpose and without fee is hereby granted, provided

- * that the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of TOSHIBA not be used in advertising

- * or publicity pertaining to distribution of the software without specific,

- * written prior permission. TOSHIBA make no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- *

- * Author: Katsuhisa Yano	TOSHIBA Corp.

- *			   	mopi@osa.ilab.toshiba.co.jp

- */

-/*

- * Copyright 1995 by FUJITSU LIMITED

- * This is source code modified by FUJITSU LIMITED under the Joint

- * Development Agreement for the CDE/Motif PST.

- */

-/*

- * Modifiers: Jeff Walls, Paul Anderson (HEWLETT-PACKARD)

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XomGeneric.h"

-#include <stdio.h>

-

-/* For VW/UDC */

-

-static int

-is_rotate(

-    XOC		oc,

-    XFontStruct	*font)

-{

-    XOCGenericPart	*gen = XOC_GENERIC(oc);

-    FontSet		font_set;

-    VRotate		vrotate;

-    int			font_set_count;

-    int			vrotate_num;

-

-    font_set = gen->font_set;

-    font_set_count = gen->font_set_num;

-    for( ; font_set_count-- ; font_set++) {

-	if((font_set->vrotate_num > 0) && (font_set->vrotate)) {

-	    vrotate = font_set->vrotate;

-	    vrotate_num = font_set->vrotate_num;

-	    for( ; vrotate_num-- ; vrotate++)

-		if(vrotate->font == font)

-		    return True;

-	}

-    }

-    return False;

-}

-

-static int

-is_codemap(

-    XOC		oc,

-    XFontStruct	*font)

-{

-    XOCGenericPart	*gen = XOC_GENERIC(oc);

-    FontSet		font_set;

-    FontData		vmap;

-    int			font_set_count;

-    int			vmap_num;

-

-    font_set = gen->font_set;

-    font_set_count = gen->font_set_num;

-    for( ; font_set_count-- ; font_set++) {

-	if(font_set->vmap_num > 0) {

-	    vmap = font_set->vmap;

-	    vmap_num = font_set->vmap_num;

-	    for( ; vmap_num-- ; vmap++)

-		if(vmap->font == font)

-		    return True;

-	}

-    }

-    return False;

-}

-

-static int

-draw_vertical(

-    Display	*dpy,

-    Drawable	d,

-    XOC		oc,

-    GC		gc,

-    XFontStruct	*font,

-    Bool	is_xchar2b,

-    int		x, int y,

-    XPointer	text,

-    int		length)

-{

-    XChar2b	*buf2b;

-    char	*buf;

-    int		wx = 0, wy = 0;

-    int		direction = 0;

-    int		font_ascent_return = 0, font_descent_return = 0;

-    int		i;

-    XCharStruct	overall;

-

-    wy = y;

-    if (is_xchar2b) {

-	for(i = 0, buf2b = (XChar2b *) text ; i < length ; i++, buf2b++) {

-	    if(is_rotate(oc, font) == True) {

-		XTextExtents16(font, buf2b, 1,

-			       &direction, &font_ascent_return,

-			       &font_descent_return, &overall);

-		wx = x - (int)((overall.rbearing - overall.lbearing) >> 1) -

-			 (int) overall.lbearing;

-		wy += overall.ascent;

-		XDrawString16(dpy, d, gc, wx, wy, buf2b, 1);

-		wy += overall.descent;

-	    } else {

-		wx = x - (int)((font->max_bounds.rbearing -

-				font->min_bounds.lbearing) >> 1) -

-			 (int) font->min_bounds.lbearing;

-		wy += font->max_bounds.ascent;

-		XDrawString16(dpy, d, gc, wx, wy, buf2b, 1);

-		wy += font->max_bounds.descent;

-	    }

-	}

-    } else {

-	for(i = 0, buf = (char *)text ; i < length && *buf ; i++, buf++) {

-	    if(is_rotate(oc, font) == True) {

-		XTextExtents(font, buf, 1,

-			     &direction, &font_ascent_return,

-			     &font_descent_return, &overall);

-		wx = x - (int)((overall.rbearing - overall.lbearing) >> 1) -

-			 (int) overall.lbearing;

-		wy += overall.ascent;

-		XDrawString(dpy, d, gc, wx, wy, buf, 1);

-		wy += overall.descent;

-	    } else {

-		wx = x - (int)((font->max_bounds.rbearing -

-				font->min_bounds.lbearing) >> 1) -

-			 (int) font->min_bounds.lbearing;

-		wy += font->max_bounds.ascent;

-		XDrawString(dpy, d, gc, wx, wy, buf, 1);

-		wy += font->max_bounds.descent;

-	    }

-	}

-    }

-    return wy;

-}

-

-#define VMAP          0

-#define VROTATE       1

-#define FONTSCOPE     2

-

-static int

-DrawStringWithFontSet(

-    Display *dpy,

-    Drawable d,

-    XOC oc,

-    FontSet fs,

-    GC gc,

-    int x, int y,

-    XPointer text,

-    int length)

-{

-    XFontStruct *font;

-    Bool is_xchar2b;

-    unsigned char *ptr;

-    int ptr_len, char_len = 0;

-    FontData fd;

-    int ret = 0;

-

-    ptr = (unsigned char *)text;

-    is_xchar2b = fs->is_xchar2b;

-

-    while (length > 0) {

-        fd = _XomGetFontDataFromFontSet(fs,

-			ptr,length,&ptr_len,is_xchar2b,FONTSCOPE);

-	if(ptr_len <= 0)

-	    break;

-

-       /* First, see if the "Best Match" font for the FontSet was set.

-	* If it was, use that font.  If it was not set, then use the

-	* font defined by font_set->font_data[0] (which is what

-	* _XomGetFontDataFromFontSet() always seems to return for

-	* non-VW text).  Note that given the new algorithm in

-	* parse_fontname() and parse_fontdata(), fs->font will

-	* *always* contain good data.   We should probably remove

-	* the check for "fd->font", but we won't :-) -- jjw/pma (HP)

-	*/

-        if((font = fs->font) == (XFontStruct *) NULL){

-

-	    if(fd == (FontData) NULL ||

-	       (font = fd->font) == (XFontStruct *) NULL)

-		break;

-        }

-

-	switch(oc->core.orientation) {

-	  case XOMOrientation_LTR_TTB:

-	  case XOMOrientation_RTL_TTB:

-            XSetFont(dpy, gc, font->fid);

-

-	    if (is_xchar2b) {

-		char_len = ptr_len / sizeof(XChar2b);

-		XDrawString16(dpy, d, gc, x, y, (XChar2b *)ptr, char_len);

-		x += XTextWidth16(font, (XChar2b *)ptr, char_len);

-            } else {

-		char_len = ptr_len;

-		XDrawString(dpy, d, gc, x, y, (char *)ptr, char_len);

-		x += XTextWidth(font, (char *)ptr, char_len);

-	    }

-	    break;

-	  case XOMOrientation_TTB_RTL:

-	  case XOMOrientation_TTB_LTR:

-	    if(fs->font == font) {

-		fd = _XomGetFontDataFromFontSet(fs,

-			ptr,length,&ptr_len,is_xchar2b,VMAP);

-		if(ptr_len <= 0)

-		    break;

-		if(fd == (FontData) NULL ||

-		   (font = fd->font) == (XFontStruct *) NULL)

-		    break;

-

-		if(is_codemap(oc, fd->font) == False) {

-		    fd = _XomGetFontDataFromFontSet(fs,

-			     ptr,length,&ptr_len,is_xchar2b,VROTATE);

-		    if(ptr_len <= 0)

-			break;

-		    if(fd == (FontData) NULL ||

-		       (font = fd->font) == (XFontStruct *) NULL)

-			break;

-		}

-	    }

-

-	    if(is_xchar2b)

-		char_len = ptr_len / sizeof(XChar2b);

-	    else

-		char_len = ptr_len;

-            XSetFont(dpy, gc, font->fid);

-	    y = draw_vertical(dpy, d, oc, gc, font, is_xchar2b, x, y,

-			       (char *)ptr, char_len);

-	    break;

-

-	  case XOMOrientation_Context:

-	    /* never used? */

-	    break;

-	}

-

-	if(char_len <= 0)

-	    break;

-

-        length -= char_len;

-        ptr += ptr_len;

-    }

-

-    switch(oc->core.orientation) {

-      case XOMOrientation_LTR_TTB:

-      case XOMOrientation_RTL_TTB:

-	ret = x;

-	break;

-      case XOMOrientation_TTB_RTL:

-      case XOMOrientation_TTB_LTR:

-	ret = y;

-	break;

-      case XOMOrientation_Context:

-	/* not used? */

-	break;

-    }

-    return ret;

-}

-

-/* For VW/UDC */

-

-int

-_XomGenericDrawString(

-    Display *dpy,

-    Drawable d,

-    XOC oc,

-    GC gc,

-    int x, int y,

-    XOMTextType type,

-    XPointer text,

-    int length)

-{

-    XlcConv conv;

-    XFontStruct *font;

-    Bool is_xchar2b;

-/* VW/UDC */

-    XPointer args[3];

-    FontSet fs;

-/* VW/UDC */

-    XChar2b xchar2b_buf[BUFSIZ], *buf;

-    int start_x = x;

-    int start_y = y;

-    int left = 0, buf_len = 0;

-    int next = 0;

-

-    conv = _XomInitConverter(oc, type);

-    if (conv == NULL)

-	return -1;

-

-    args[0] = (XPointer) &font;

-    args[1] = (XPointer) &is_xchar2b;

-    args[2] = (XPointer) &fs;

-

-    while (length > 0) {

-	buf = xchar2b_buf;

-	left = buf_len = BUFSIZ;

-

-	if (_XomConvert(oc, conv, (XPointer *) &text, &length,

-			(XPointer *) &buf, &left, args, 3) < 0)

-	    break;

-	buf_len -= left;

-

-/* For VW/UDC */

-	next = DrawStringWithFontSet(dpy, d, oc, fs, gc, x, y,

-				     (XPointer)xchar2b_buf, buf_len);

-

-	switch(oc->core.orientation) {

-	  case XOMOrientation_LTR_TTB:

-	  case XOMOrientation_RTL_TTB:

-	    x = next;

-	    break;

-	  case XOMOrientation_TTB_RTL:

-	  case XOMOrientation_TTB_LTR:

-	    y = next;

-	    break;

-          case XOMOrientation_Context:

-	    /* not used */

-	    break;

-	}

-/* For VW/UDC */

-    }

-

-    x -= start_x;

-    y -= start_y;

-

-    return x;

-}

-

-int

-_XmbGenericDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,

-		      _Xconst char *text, int length)

-{

-    return _XomGenericDrawString(dpy, d, oc, gc, x, y, XOMMultiByte,

-				 (XPointer) text, length);

-}

-

-int

-_XwcGenericDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,

-		      _Xconst wchar_t *text, int length)

-{

-    return _XomGenericDrawString(dpy, d, oc, gc, x, y, XOMWideChar,

-				 (XPointer) text, length);

-}

-

-int

-_Xutf8GenericDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,

-			_Xconst char *text, int length)

-{

-    return _XomGenericDrawString(dpy, d, oc, gc, x, y, XOMUtf8String,

-				 (XPointer) text, length);

-}

+/*
+ * Copyright 1992, 1993 by TOSHIBA Corp.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of TOSHIBA not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission. TOSHIBA make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * Author: Katsuhisa Yano	TOSHIBA Corp.
+ *			   	mopi@osa.ilab.toshiba.co.jp
+ */
+/*
+ * Copyright 1995 by FUJITSU LIMITED
+ * This is source code modified by FUJITSU LIMITED under the Joint
+ * Development Agreement for the CDE/Motif PST.
+ */
+/*
+ * Modifiers: Jeff Walls, Paul Anderson (HEWLETT-PACKARD)
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XomGeneric.h"
+#include <stdio.h>
+
+/* For VW/UDC */
+
+static int
+is_rotate(
+    XOC		oc,
+    XFontStruct	*font)
+{
+    XOCGenericPart	*gen = XOC_GENERIC(oc);
+    FontSet		font_set;
+    VRotate		vrotate;
+    int			font_set_count;
+    int			vrotate_num;
+
+    font_set = gen->font_set;
+    font_set_count = gen->font_set_num;
+    for( ; font_set_count-- ; font_set++) {
+	if((font_set->vrotate_num > 0) && (font_set->vrotate)) {
+	    vrotate = font_set->vrotate;
+	    vrotate_num = font_set->vrotate_num;
+	    for( ; vrotate_num-- ; vrotate++)
+		if(vrotate->font == font)
+		    return True;
+	}
+    }
+    return False;
+}
+
+static int
+is_codemap(
+    XOC		oc,
+    XFontStruct	*font)
+{
+    XOCGenericPart	*gen = XOC_GENERIC(oc);
+    FontSet		font_set;
+    FontData		vmap;
+    int			font_set_count;
+    int			vmap_num;
+
+    font_set = gen->font_set;
+    font_set_count = gen->font_set_num;
+    for( ; font_set_count-- ; font_set++) {
+	if(font_set->vmap_num > 0) {
+	    vmap = font_set->vmap;
+	    vmap_num = font_set->vmap_num;
+	    for( ; vmap_num-- ; vmap++)
+		if(vmap->font == font)
+		    return True;
+	}
+    }
+    return False;
+}
+
+static int
+draw_vertical(
+    Display	*dpy,
+    Drawable	d,
+    XOC		oc,
+    GC		gc,
+    XFontStruct	*font,
+    Bool	is_xchar2b,
+    int		x, int y,
+    XPointer	text,
+    int		length)
+{
+    XChar2b	*buf2b;
+    char	*buf;
+    int		wx = 0, wy = 0;
+    int		direction = 0;
+    int		font_ascent_return = 0, font_descent_return = 0;
+    int		i;
+    XCharStruct	overall;
+
+    wy = y;
+    if (is_xchar2b) {
+	for(i = 0, buf2b = (XChar2b *) text ; i < length ; i++, buf2b++) {
+	    if(is_rotate(oc, font) == True) {
+		XTextExtents16(font, buf2b, 1,
+			       &direction, &font_ascent_return,
+			       &font_descent_return, &overall);
+		wx = x - (int)((overall.rbearing - overall.lbearing) >> 1) -
+			 (int) overall.lbearing;
+		wy += overall.ascent;
+		XDrawString16(dpy, d, gc, wx, wy, buf2b, 1);
+		wy += overall.descent;
+	    } else {
+		wx = x - (int)((font->max_bounds.rbearing -
+				font->min_bounds.lbearing) >> 1) -
+			 (int) font->min_bounds.lbearing;
+		wy += font->max_bounds.ascent;
+		XDrawString16(dpy, d, gc, wx, wy, buf2b, 1);
+		wy += font->max_bounds.descent;
+	    }
+	}
+    } else {
+	for(i = 0, buf = (char *)text ; i < length && *buf ; i++, buf++) {
+	    if(is_rotate(oc, font) == True) {
+		XTextExtents(font, buf, 1,
+			     &direction, &font_ascent_return,
+			     &font_descent_return, &overall);
+		wx = x - (int)((overall.rbearing - overall.lbearing) >> 1) -
+			 (int) overall.lbearing;
+		wy += overall.ascent;
+		XDrawString(dpy, d, gc, wx, wy, buf, 1);
+		wy += overall.descent;
+	    } else {
+		wx = x - (int)((font->max_bounds.rbearing -
+				font->min_bounds.lbearing) >> 1) -
+			 (int) font->min_bounds.lbearing;
+		wy += font->max_bounds.ascent;
+		XDrawString(dpy, d, gc, wx, wy, buf, 1);
+		wy += font->max_bounds.descent;
+	    }
+	}
+    }
+    return wy;
+}
+
+#define VMAP          0
+#define VROTATE       1
+#define FONTSCOPE     2
+
+static int
+DrawStringWithFontSet(
+    Display *dpy,
+    Drawable d,
+    XOC oc,
+    FontSet fs,
+    GC gc,
+    int x, int y,
+    XPointer text,
+    int length)
+{
+    XFontStruct *font;
+    Bool is_xchar2b;
+    unsigned char *ptr;
+    int ptr_len, char_len = 0;
+    FontData fd;
+    int ret = 0;
+
+    ptr = (unsigned char *)text;
+    is_xchar2b = fs->is_xchar2b;
+
+    while (length > 0) {
+        fd = _XomGetFontDataFromFontSet(fs,
+			ptr,length,&ptr_len,is_xchar2b,FONTSCOPE);
+	if(ptr_len <= 0)
+	    break;
+
+       /* First, see if the "Best Match" font for the FontSet was set.
+	* If it was, use that font.  If it was not set, then use the
+	* font defined by font_set->font_data[0] (which is what
+	* _XomGetFontDataFromFontSet() always seems to return for
+	* non-VW text).  Note that given the new algorithm in
+	* parse_fontname() and parse_fontdata(), fs->font will
+	* *always* contain good data.   We should probably remove
+	* the check for "fd->font", but we won't :-) -- jjw/pma (HP)
+	*/
+        if((font = fs->font) == (XFontStruct *) NULL){
+
+	    if(fd == (FontData) NULL ||
+	       (font = fd->font) == (XFontStruct *) NULL)
+		break;
+        }
+
+	switch(oc->core.orientation) {
+	  case XOMOrientation_LTR_TTB:
+	  case XOMOrientation_RTL_TTB:
+            XSetFont(dpy, gc, font->fid);
+
+	    if (is_xchar2b) {
+		char_len = ptr_len / sizeof(XChar2b);
+		XDrawString16(dpy, d, gc, x, y, (XChar2b *)ptr, char_len);
+		x += XTextWidth16(font, (XChar2b *)ptr, char_len);
+            } else {
+		char_len = ptr_len;
+		XDrawString(dpy, d, gc, x, y, (char *)ptr, char_len);
+		x += XTextWidth(font, (char *)ptr, char_len);
+	    }
+	    break;
+	  case XOMOrientation_TTB_RTL:
+	  case XOMOrientation_TTB_LTR:
+	    if(fs->font == font) {
+		fd = _XomGetFontDataFromFontSet(fs,
+			ptr,length,&ptr_len,is_xchar2b,VMAP);
+		if(ptr_len <= 0)
+		    break;
+		if(fd == (FontData) NULL ||
+		   (font = fd->font) == (XFontStruct *) NULL)
+		    break;
+
+		if(is_codemap(oc, fd->font) == False) {
+		    fd = _XomGetFontDataFromFontSet(fs,
+			     ptr,length,&ptr_len,is_xchar2b,VROTATE);
+		    if(ptr_len <= 0)
+			break;
+		    if(fd == (FontData) NULL ||
+		       (font = fd->font) == (XFontStruct *) NULL)
+			break;
+		}
+	    }
+
+	    if(is_xchar2b)
+		char_len = ptr_len / sizeof(XChar2b);
+	    else
+		char_len = ptr_len;
+            XSetFont(dpy, gc, font->fid);
+	    y = draw_vertical(dpy, d, oc, gc, font, is_xchar2b, x, y,
+			       (char *)ptr, char_len);
+	    break;
+
+	  case XOMOrientation_Context:
+	    /* never used? */
+	    break;
+	}
+
+	if(char_len <= 0)
+	    break;
+
+        length -= char_len;
+        ptr += ptr_len;
+    }
+
+    switch(oc->core.orientation) {
+      case XOMOrientation_LTR_TTB:
+      case XOMOrientation_RTL_TTB:
+	ret = x;
+	break;
+      case XOMOrientation_TTB_RTL:
+      case XOMOrientation_TTB_LTR:
+	ret = y;
+	break;
+      case XOMOrientation_Context:
+	/* not used? */
+	break;
+    }
+    return ret;
+}
+
+/* For VW/UDC */
+
+int
+_XomGenericDrawString(
+    Display *dpy,
+    Drawable d,
+    XOC oc,
+    GC gc,
+    int x, int y,
+    XOMTextType type,
+    XPointer text,
+    int length)
+{
+    XlcConv conv;
+    XFontStruct *font;
+    Bool is_xchar2b;
+/* VW/UDC */
+    XPointer args[3];
+    FontSet fs;
+/* VW/UDC */
+    XChar2b xchar2b_buf[BUFSIZ], *buf;
+    int start_x = x;
+    int start_y = y;
+    int left = 0, buf_len = 0;
+    int next = 0;
+
+    conv = _XomInitConverter(oc, type);
+    if (conv == NULL)
+	return -1;
+
+    args[0] = (XPointer) &font;
+    args[1] = (XPointer) &is_xchar2b;
+    args[2] = (XPointer) &fs;
+
+    while (length > 0) {
+	buf = xchar2b_buf;
+	left = buf_len = BUFSIZ;
+
+	if (_XomConvert(oc, conv, (XPointer *) &text, &length,
+			(XPointer *) &buf, &left, args, 3) < 0)
+	    break;
+	buf_len -= left;
+
+/* For VW/UDC */
+	next = DrawStringWithFontSet(dpy, d, oc, fs, gc, x, y,
+				     (XPointer)xchar2b_buf, buf_len);
+
+	switch(oc->core.orientation) {
+	  case XOMOrientation_LTR_TTB:
+	  case XOMOrientation_RTL_TTB:
+	    x = next;
+	    break;
+	  case XOMOrientation_TTB_RTL:
+	  case XOMOrientation_TTB_LTR:
+	    y = next;
+	    break;
+          case XOMOrientation_Context:
+	    /* not used */
+	    break;
+	}
+/* For VW/UDC */
+    }
+
+    x -= start_x;
+    y -= start_y;
+
+    return x;
+}
+
+int
+_XmbGenericDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,
+		      _Xconst char *text, int length)
+{
+    return _XomGenericDrawString(dpy, d, oc, gc, x, y, XOMMultiByte,
+				 (XPointer) text, length);
+}
+
+int
+_XwcGenericDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,
+		      _Xconst wchar_t *text, int length)
+{
+    return _XomGenericDrawString(dpy, d, oc, gc, x, y, XOMWideChar,
+				 (XPointer) text, length);
+}
+
+int
+_Xutf8GenericDrawString(Display *dpy, Drawable d, XOC oc, GC gc, int x, int y,
+			_Xconst char *text, int length)
+{
+    return _XomGenericDrawString(dpy, d, oc, gc, x, y, XOMUtf8String,
+				 (XPointer) text, length);
+}
diff --git a/libX11/modules/om/generic/omTextEsc.c b/libX11/modules/om/generic/omTextEsc.c
index cb444f441..df1fb10c0 100644
--- a/libX11/modules/om/generic/omTextEsc.c
+++ b/libX11/modules/om/generic/omTextEsc.c
@@ -1,300 +1,300 @@
-/*

- * Copyright 1992, 1993 by TOSHIBA Corp.

- *

- * Permission to use, copy, modify, and distribute this software and its

- * documentation for any purpose and without fee is hereby granted, provided

- * that the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of TOSHIBA not be used in advertising

- * or publicity pertaining to distribution of the software without specific,

- * written prior permission. TOSHIBA make no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- *

- * Author: Katsuhisa Yano	TOSHIBA Corp.

- *			   	mopi@osa.ilab.toshiba.co.jp

- */

-/*

- * Copyright 1995 by FUJITSU LIMITED

- * This is source code modified by FUJITSU LIMITED under the Joint

- * Development Agreement for the CDE/Motif PST.

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XomGeneric.h"

-#include <stdio.h>

-

-/* For VW/UDC start */

-

-#define	VMAP		0

-#define	VROTATE		1

-#define	FONTSCOPE	2

-

-static int

-is_rotate(

-    XOC         oc,

-    XFontStruct *font)

-{

-    XOCGenericPart      *gen = XOC_GENERIC(oc);

-    FontSet             font_set;

-    VRotate             vrotate;

-    int                 font_set_count;

-    int                 vrotate_num;

-

-    font_set = gen->font_set;

-    font_set_count = gen->font_set_num;

-    for( ; font_set_count-- ; font_set++) {

-	if((font_set->vrotate_num > 0) && (font_set->vrotate != NULL)) {

-	    vrotate = font_set->vrotate;

-	    vrotate_num = font_set->vrotate_num;

-	    for( ; vrotate_num-- ; vrotate++)

-		if(vrotate->font == font)

-		    return True;

-	}

-    }

-    return False;

-}

-

-static int

-is_codemap(

-    XOC         oc,

-    XFontStruct *font)

-{

-    XOCGenericPart      *gen = XOC_GENERIC(oc);

-    FontSet             font_set;

-    FontData            vmap;

-    int                 font_set_count;

-    int                 vmap_num;

-

-    font_set = gen->font_set;

-    font_set_count = gen->font_set_num;

-    for( ; font_set_count-- ; font_set++) {

-	if(font_set->vmap_num > 0) {

-	    vmap = font_set->vmap;

-	    vmap_num = font_set->vmap_num;

-	    for( ; vmap_num-- ; vmap++)

-		if(vmap->font == font)

-		    return True;

-	}

-    }

-    return False;

-}

-

-static int

-escapement_vertical(

-    XOC         oc,

-    XFontStruct *font,

-    Bool        is_xchar2b,

-    XPointer    text,

-    int         length)

-{

-    XChar2b	*buf2b;

-    char	*buf;

-    int		escapement = 0, i;

-

-    if(is_xchar2b) {

-	for(i = 0, buf2b = (XChar2b *) text ; i < length ; i++, buf2b++) {

-	    if(is_rotate(oc, font) == True) {

-		escapement += _XTextHeight16(font, buf2b, 1);

-	    } else {

-		escapement += (int) (font->max_bounds.ascent +

-				     font->max_bounds.descent);

-	    }

-	}

-    } else {

-	for(i = 0, buf = (char *)text ; i < length && *buf ; i++, buf++) {

-	    if(is_rotate(oc, font) == True) {

-		escapement += _XTextHeight(font, buf, 1);

-	    } else {

-		escapement += (int) (font->max_bounds.ascent +

-				     font->max_bounds.descent);

-	    }

-	}

-    }

-    return escapement;

-}

-

-

-static int

-TextWidthWithFontSet(

-    FontSet	font_set,

-    XOC		oc,

-    XPointer    text,

-    int         length)

-{

-    FontData		fd;

-    XFontStruct		*font;

-    unsigned char	*ptr = (unsigned char *)text;

-    Bool        	is_xchar2b;

-    int			ptr_len = length;

-    int			escapement = 0, char_len = 0;

-

-    if(font_set == (FontSet) NULL)

-	return escapement;

-

-    is_xchar2b = font_set->is_xchar2b;

-

-    while(length > 0) {

-	fd = _XomGetFontDataFromFontSet(font_set, ptr, length, &ptr_len,

-					       is_xchar2b, FONTSCOPE);

-	if(ptr_len <= 0)

-	    break;

-

-	/*

-	 * First, see if the "Best Match" font for the FontSet was set.

-	 * If it was, use that font.  If it was not set, then use the

-	 * font defined by font_set->font_data[0] (which is what

-	 * _XomGetFontDataFromFontSet() always seems to return for

-	 * non-VW text).  Note that given the new algorithm in

-	 * parse_fontname() and parse_fontdata(), fs->font will

-	 * *always* contain good data.   We should probably remove

-	 * the check for "fd->font", but we won't :-) -- jjw/pma (HP)

-	 *

-	 * Above comment and way this is done propagated from omText.c

-	 * Note that fd->font is junk so using the result of the

-	 * above call /needs/ to be ignored.

-	 *

-	 * Owen Taylor <otaylor@redhat.com>     12 Jul 2000

-	 *

-	 */

-

-	if(fd == (FontData) NULL ||

-	   (font = font_set->font) == (XFontStruct *) NULL) {

-

-	    if((font = fd->font) == (XFontStruct *) NULL)

-		break;

-	}

-

-	switch(oc->core.orientation) {

-	  case XOMOrientation_LTR_TTB:

-	  case XOMOrientation_RTL_TTB:

-	    if (is_xchar2b) {

-		char_len = ptr_len / sizeof(XChar2b);

-		escapement += XTextWidth16(font, (XChar2b *)ptr, char_len);

-	    } else {

-		char_len = ptr_len;

-		escapement += XTextWidth(font, (char *)ptr, char_len);

-	    }

-	    break;

-

-	  case XOMOrientation_TTB_LTR:

-	  case XOMOrientation_TTB_RTL:

-	    if(font_set->font == font) {

-		fd = _XomGetFontDataFromFontSet(font_set, ptr, length, &ptr_len,

-						is_xchar2b, VMAP);

-		if(ptr_len <= 0)

-		    break;

-		if(fd == (FontData) NULL ||

-		   (font = fd->font) == (XFontStruct *) NULL)

-		    break;

-

-		if(is_codemap(oc, fd->font) == False) {

-		    fd = _XomGetFontDataFromFontSet(font_set, ptr, length,

-						    &ptr_len, is_xchar2b,

-						    VROTATE);

-		    if(ptr_len <= 0)

-			break;

-		    if(fd == (FontData) NULL ||

-		       (font = fd->font) == (XFontStruct *) NULL)

-			break;

-		}

-	    }

-

-	    if(is_xchar2b)

-		char_len = ptr_len / sizeof(XChar2b);

-	    else

-		char_len = ptr_len;

-	    escapement += escapement_vertical(oc, font, is_xchar2b,

-					      (XPointer) ptr, char_len);

-	    break;

-

-	  case XOMOrientation_Context:

-	    /* not used? */

-            break;

-	}

-

-	if(char_len <= 0)

-	    break;

-

-	length -= char_len;

-	ptr += ptr_len;

-    }

-

-    return escapement;

-}

-

-/* For VW/UDC end */

-

-static int

-_XomGenericTextEscapement(

-    XOC oc,

-    XOMTextType type,

-    XPointer text,

-    int length)

-{

-    XlcConv conv;

-    XFontStruct *font;

-    Bool is_xchar2b;

-/* VW/UDC */

-    XPointer args[3];

-    FontSet font_set;

-/* VW/UDC */

-    XChar2b xchar2b_buf[BUFSIZ], *buf;

-    int escapement = 0;

-    int buf_len = 0, left = 0;

-

-    conv = _XomInitConverter(oc, type);

-    if (conv == NULL)

-	return escapement;

-

-    args[0] = (XPointer) &font;

-    args[1] = (XPointer) &is_xchar2b;

-    args[2] = (XPointer) &font_set;

-

-    while (length > 0) {

-	buf = xchar2b_buf;

-	left = buf_len = BUFSIZ;

-

-	if (_XomConvert(oc, conv, (XPointer *) &text, &length,

-			(XPointer *) &buf, &left, args, 3) < 0)

-	    break;

-	buf_len -= left;

-

-/* VW/UDC */

-	escapement += TextWidthWithFontSet(font_set, oc,

-					   (XPointer) xchar2b_buf, buf_len);

-/* VW/UDC */

-    }

-

-    return escapement;

-}

-

-int

-_XmbGenericTextEscapement(XOC oc, _Xconst char *text, int length)

-{

-    return _XomGenericTextEscapement(oc, XOMMultiByte, (XPointer) text, length);

-}

-

-int

-_XwcGenericTextEscapement(XOC oc, _Xconst wchar_t *text, int length)

-{

-    return _XomGenericTextEscapement(oc, XOMWideChar, (XPointer) text, length);

-}

-

-int

-_Xutf8GenericTextEscapement(XOC oc, _Xconst char *text, int length)

-{

-    return _XomGenericTextEscapement(oc, XOMUtf8String, (XPointer) text,

-				     length);

-}

+/*
+ * Copyright 1992, 1993 by TOSHIBA Corp.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of TOSHIBA not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission. TOSHIBA make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * Author: Katsuhisa Yano	TOSHIBA Corp.
+ *			   	mopi@osa.ilab.toshiba.co.jp
+ */
+/*
+ * Copyright 1995 by FUJITSU LIMITED
+ * This is source code modified by FUJITSU LIMITED under the Joint
+ * Development Agreement for the CDE/Motif PST.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XomGeneric.h"
+#include <stdio.h>
+
+/* For VW/UDC start */
+
+#define	VMAP		0
+#define	VROTATE		1
+#define	FONTSCOPE	2
+
+static int
+is_rotate(
+    XOC         oc,
+    XFontStruct *font)
+{
+    XOCGenericPart      *gen = XOC_GENERIC(oc);
+    FontSet             font_set;
+    VRotate             vrotate;
+    int                 font_set_count;
+    int                 vrotate_num;
+
+    font_set = gen->font_set;
+    font_set_count = gen->font_set_num;
+    for( ; font_set_count-- ; font_set++) {
+	if((font_set->vrotate_num > 0) && (font_set->vrotate != NULL)) {
+	    vrotate = font_set->vrotate;
+	    vrotate_num = font_set->vrotate_num;
+	    for( ; vrotate_num-- ; vrotate++)
+		if(vrotate->font == font)
+		    return True;
+	}
+    }
+    return False;
+}
+
+static int
+is_codemap(
+    XOC         oc,
+    XFontStruct *font)
+{
+    XOCGenericPart      *gen = XOC_GENERIC(oc);
+    FontSet             font_set;
+    FontData            vmap;
+    int                 font_set_count;
+    int                 vmap_num;
+
+    font_set = gen->font_set;
+    font_set_count = gen->font_set_num;
+    for( ; font_set_count-- ; font_set++) {
+	if(font_set->vmap_num > 0) {
+	    vmap = font_set->vmap;
+	    vmap_num = font_set->vmap_num;
+	    for( ; vmap_num-- ; vmap++)
+		if(vmap->font == font)
+		    return True;
+	}
+    }
+    return False;
+}
+
+static int
+escapement_vertical(
+    XOC         oc,
+    XFontStruct *font,
+    Bool        is_xchar2b,
+    XPointer    text,
+    int         length)
+{
+    XChar2b	*buf2b;
+    char	*buf;
+    int		escapement = 0, i;
+
+    if(is_xchar2b) {
+	for(i = 0, buf2b = (XChar2b *) text ; i < length ; i++, buf2b++) {
+	    if(is_rotate(oc, font) == True) {
+		escapement += _XTextHeight16(font, buf2b, 1);
+	    } else {
+		escapement += (int) (font->max_bounds.ascent +
+				     font->max_bounds.descent);
+	    }
+	}
+    } else {
+	for(i = 0, buf = (char *)text ; i < length && *buf ; i++, buf++) {
+	    if(is_rotate(oc, font) == True) {
+		escapement += _XTextHeight(font, buf, 1);
+	    } else {
+		escapement += (int) (font->max_bounds.ascent +
+				     font->max_bounds.descent);
+	    }
+	}
+    }
+    return escapement;
+}
+
+
+static int
+TextWidthWithFontSet(
+    FontSet	font_set,
+    XOC		oc,
+    XPointer    text,
+    int         length)
+{
+    FontData		fd;
+    XFontStruct		*font;
+    unsigned char	*ptr = (unsigned char *)text;
+    Bool        	is_xchar2b;
+    int			ptr_len = length;
+    int			escapement = 0, char_len = 0;
+
+    if(font_set == (FontSet) NULL)
+	return escapement;
+
+    is_xchar2b = font_set->is_xchar2b;
+
+    while(length > 0) {
+	fd = _XomGetFontDataFromFontSet(font_set, ptr, length, &ptr_len,
+					       is_xchar2b, FONTSCOPE);
+	if(ptr_len <= 0)
+	    break;
+
+	/*
+	 * First, see if the "Best Match" font for the FontSet was set.
+	 * If it was, use that font.  If it was not set, then use the
+	 * font defined by font_set->font_data[0] (which is what
+	 * _XomGetFontDataFromFontSet() always seems to return for
+	 * non-VW text).  Note that given the new algorithm in
+	 * parse_fontname() and parse_fontdata(), fs->font will
+	 * *always* contain good data.   We should probably remove
+	 * the check for "fd->font", but we won't :-) -- jjw/pma (HP)
+	 *
+	 * Above comment and way this is done propagated from omText.c
+	 * Note that fd->font is junk so using the result of the
+	 * above call /needs/ to be ignored.
+	 *
+	 * Owen Taylor <otaylor@redhat.com>     12 Jul 2000
+	 *
+	 */
+
+	if(fd == (FontData) NULL ||
+	   (font = font_set->font) == (XFontStruct *) NULL) {
+
+	    if((font = fd->font) == (XFontStruct *) NULL)
+		break;
+	}
+
+	switch(oc->core.orientation) {
+	  case XOMOrientation_LTR_TTB:
+	  case XOMOrientation_RTL_TTB:
+	    if (is_xchar2b) {
+		char_len = ptr_len / sizeof(XChar2b);
+		escapement += XTextWidth16(font, (XChar2b *)ptr, char_len);
+	    } else {
+		char_len = ptr_len;
+		escapement += XTextWidth(font, (char *)ptr, char_len);
+	    }
+	    break;
+
+	  case XOMOrientation_TTB_LTR:
+	  case XOMOrientation_TTB_RTL:
+	    if(font_set->font == font) {
+		fd = _XomGetFontDataFromFontSet(font_set, ptr, length, &ptr_len,
+						is_xchar2b, VMAP);
+		if(ptr_len <= 0)
+		    break;
+		if(fd == (FontData) NULL ||
+		   (font = fd->font) == (XFontStruct *) NULL)
+		    break;
+
+		if(is_codemap(oc, fd->font) == False) {
+		    fd = _XomGetFontDataFromFontSet(font_set, ptr, length,
+						    &ptr_len, is_xchar2b,
+						    VROTATE);
+		    if(ptr_len <= 0)
+			break;
+		    if(fd == (FontData) NULL ||
+		       (font = fd->font) == (XFontStruct *) NULL)
+			break;
+		}
+	    }
+
+	    if(is_xchar2b)
+		char_len = ptr_len / sizeof(XChar2b);
+	    else
+		char_len = ptr_len;
+	    escapement += escapement_vertical(oc, font, is_xchar2b,
+					      (XPointer) ptr, char_len);
+	    break;
+
+	  case XOMOrientation_Context:
+	    /* not used? */
+            break;
+	}
+
+	if(char_len <= 0)
+	    break;
+
+	length -= char_len;
+	ptr += ptr_len;
+    }
+
+    return escapement;
+}
+
+/* For VW/UDC end */
+
+static int
+_XomGenericTextEscapement(
+    XOC oc,
+    XOMTextType type,
+    XPointer text,
+    int length)
+{
+    XlcConv conv;
+    XFontStruct *font;
+    Bool is_xchar2b;
+/* VW/UDC */
+    XPointer args[3];
+    FontSet font_set;
+/* VW/UDC */
+    XChar2b xchar2b_buf[BUFSIZ], *buf;
+    int escapement = 0;
+    int buf_len = 0, left = 0;
+
+    conv = _XomInitConverter(oc, type);
+    if (conv == NULL)
+	return escapement;
+
+    args[0] = (XPointer) &font;
+    args[1] = (XPointer) &is_xchar2b;
+    args[2] = (XPointer) &font_set;
+
+    while (length > 0) {
+	buf = xchar2b_buf;
+	left = buf_len = BUFSIZ;
+
+	if (_XomConvert(oc, conv, (XPointer *) &text, &length,
+			(XPointer *) &buf, &left, args, 3) < 0)
+	    break;
+	buf_len -= left;
+
+/* VW/UDC */
+	escapement += TextWidthWithFontSet(font_set, oc,
+					   (XPointer) xchar2b_buf, buf_len);
+/* VW/UDC */
+    }
+
+    return escapement;
+}
+
+int
+_XmbGenericTextEscapement(XOC oc, _Xconst char *text, int length)
+{
+    return _XomGenericTextEscapement(oc, XOMMultiByte, (XPointer) text, length);
+}
+
+int
+_XwcGenericTextEscapement(XOC oc, _Xconst wchar_t *text, int length)
+{
+    return _XomGenericTextEscapement(oc, XOMWideChar, (XPointer) text, length);
+}
+
+int
+_Xutf8GenericTextEscapement(XOC oc, _Xconst char *text, int length)
+{
+    return _XomGenericTextEscapement(oc, XOMUtf8String, (XPointer) text,
+				     length);
+}
diff --git a/libX11/modules/om/generic/omTextExt.c b/libX11/modules/om/generic/omTextExt.c
index 22f99d8f5..baeadf6b0 100644
--- a/libX11/modules/om/generic/omTextExt.c
+++ b/libX11/modules/om/generic/omTextExt.c
@@ -1,135 +1,135 @@
-/*

- * Copyright 1992, 1993 by TOSHIBA Corp.

- *

- * Permission to use, copy, modify, and distribute this software and its

- * documentation for any purpose and without fee is hereby granted, provided

- * that the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of TOSHIBA not be used in advertising

- * or publicity pertaining to distribution of the software without specific,

- * written prior permission. TOSHIBA make no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- *

- * Author: Katsuhisa Yano	TOSHIBA Corp.

- *			   	mopi@osa.ilab.toshiba.co.jp

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XomGeneric.h"

-#include <stdio.h>

-

-int

-_XomGenericTextExtents(

-    XOC oc,

-    XOMTextType type,

-    XPointer text,

-    int length,

-    XRectangle *overall_ink,

-    XRectangle *overall_logical)

-{

-    XlcConv conv;

-    XFontStruct *font;

-    Bool is_xchar2b;

-    XPointer args[2];

-    XChar2b xchar2b_buf[BUFSIZ], *buf;

-    int direction, logical_ascent, logical_descent, tmp_ascent, tmp_descent;

-    XCharStruct overall, tmp_overall;

-    int buf_len, left;

-    Bool first = True;

-

-    conv = _XomInitConverter(oc, type);

-    if (conv == NULL)

-	return 0;

-

-    bzero((char *) &overall, sizeof(XCharStruct));

-    logical_ascent = logical_descent = 0;

-

-    args[0] = (XPointer) &font;

-    args[1] = (XPointer) &is_xchar2b;

-

-    while (length > 0) {

-	buf = xchar2b_buf;

-	left = buf_len = BUFSIZ;

-

-	if (_XomConvert(oc, conv, (XPointer *) &text, &length,

-			(XPointer *) &buf, &left, args, 2) < 0)

-	    break;

-	buf_len -= left;

-

-	if (is_xchar2b)

-	    XTextExtents16(font, xchar2b_buf, buf_len, &direction,

-			   &tmp_ascent, &tmp_descent, &tmp_overall);

-	else

-	    XTextExtents(font, (char *) xchar2b_buf, buf_len, &direction,

-			 &tmp_ascent, &tmp_descent, &tmp_overall);

-

-	if (first) {	/* initialize overall */

-	    overall = tmp_overall;

-	    logical_ascent = tmp_ascent;

-	    logical_descent = tmp_descent;

-	    first = False;

-	} else {

-	    overall.lbearing = min(overall.lbearing,

-				   overall.width + tmp_overall.lbearing);

-	    overall.rbearing = max(overall.rbearing,

-				   overall.width + tmp_overall.rbearing);

-	    overall.ascent = max(overall.ascent, tmp_overall.ascent);

-	    overall.descent = max(overall.descent, tmp_overall.descent);

-	    overall.width += tmp_overall.width;

-	    logical_ascent = max(logical_ascent, tmp_ascent);

-	    logical_descent = max(logical_descent, tmp_descent);

-	}

-    }

-

-    if (overall_ink) {

-	overall_ink->x = overall.lbearing;

-	overall_ink->y = -(overall.ascent);

-	overall_ink->width = overall.rbearing - overall.lbearing;

-	overall_ink->height = overall.ascent + overall.descent;

-    }

-

-    if (overall_logical) {

-	overall_logical->x = 0;

-        overall_logical->y = -(logical_ascent);

-	overall_logical->width = overall.width;

-        overall_logical->height = logical_ascent + logical_descent;

-    }

-

-    return overall.width;

-}

-

-int

-_XmbGenericTextExtents(XOC oc, _Xconst char *text, int length,

-		       XRectangle *overall_ink, XRectangle *overall_logical)

-{

-    return _XomGenericTextExtents(oc, XOMMultiByte, (XPointer) text, length,

-				  overall_ink, overall_logical);

-}

-

-int

-_XwcGenericTextExtents(XOC oc, _Xconst wchar_t *text, int length,

-		       XRectangle *overall_ink, XRectangle *overall_logical)

-{

-    return _XomGenericTextExtents(oc, XOMWideChar, (XPointer) text, length,

-				  overall_ink, overall_logical);

-}

-

-int

-_Xutf8GenericTextExtents(XOC oc, _Xconst char *text, int length,

-			 XRectangle *overall_ink, XRectangle *overall_logical)

-{

-    return _XomGenericTextExtents(oc, XOMUtf8String, (XPointer) text, length,

-				  overall_ink, overall_logical);

-}

+/*
+ * Copyright 1992, 1993 by TOSHIBA Corp.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of TOSHIBA not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission. TOSHIBA make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * Author: Katsuhisa Yano	TOSHIBA Corp.
+ *			   	mopi@osa.ilab.toshiba.co.jp
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XomGeneric.h"
+#include <stdio.h>
+
+int
+_XomGenericTextExtents(
+    XOC oc,
+    XOMTextType type,
+    XPointer text,
+    int length,
+    XRectangle *overall_ink,
+    XRectangle *overall_logical)
+{
+    XlcConv conv;
+    XFontStruct *font;
+    Bool is_xchar2b;
+    XPointer args[2];
+    XChar2b xchar2b_buf[BUFSIZ], *buf;
+    int direction, logical_ascent, logical_descent, tmp_ascent, tmp_descent;
+    XCharStruct overall, tmp_overall;
+    int buf_len, left;
+    Bool first = True;
+
+    conv = _XomInitConverter(oc, type);
+    if (conv == NULL)
+	return 0;
+
+    bzero((char *) &overall, sizeof(XCharStruct));
+    logical_ascent = logical_descent = 0;
+
+    args[0] = (XPointer) &font;
+    args[1] = (XPointer) &is_xchar2b;
+
+    while (length > 0) {
+	buf = xchar2b_buf;
+	left = buf_len = BUFSIZ;
+
+	if (_XomConvert(oc, conv, (XPointer *) &text, &length,
+			(XPointer *) &buf, &left, args, 2) < 0)
+	    break;
+	buf_len -= left;
+
+	if (is_xchar2b)
+	    XTextExtents16(font, xchar2b_buf, buf_len, &direction,
+			   &tmp_ascent, &tmp_descent, &tmp_overall);
+	else
+	    XTextExtents(font, (char *) xchar2b_buf, buf_len, &direction,
+			 &tmp_ascent, &tmp_descent, &tmp_overall);
+
+	if (first) {	/* initialize overall */
+	    overall = tmp_overall;
+	    logical_ascent = tmp_ascent;
+	    logical_descent = tmp_descent;
+	    first = False;
+	} else {
+	    overall.lbearing = min(overall.lbearing,
+				   overall.width + tmp_overall.lbearing);
+	    overall.rbearing = max(overall.rbearing,
+				   overall.width + tmp_overall.rbearing);
+	    overall.ascent = max(overall.ascent, tmp_overall.ascent);
+	    overall.descent = max(overall.descent, tmp_overall.descent);
+	    overall.width += tmp_overall.width;
+	    logical_ascent = max(logical_ascent, tmp_ascent);
+	    logical_descent = max(logical_descent, tmp_descent);
+	}
+    }
+
+    if (overall_ink) {
+	overall_ink->x = overall.lbearing;
+	overall_ink->y = -(overall.ascent);
+	overall_ink->width = overall.rbearing - overall.lbearing;
+	overall_ink->height = overall.ascent + overall.descent;
+    }
+
+    if (overall_logical) {
+	overall_logical->x = 0;
+        overall_logical->y = -(logical_ascent);
+	overall_logical->width = overall.width;
+        overall_logical->height = logical_ascent + logical_descent;
+    }
+
+    return overall.width;
+}
+
+int
+_XmbGenericTextExtents(XOC oc, _Xconst char *text, int length,
+		       XRectangle *overall_ink, XRectangle *overall_logical)
+{
+    return _XomGenericTextExtents(oc, XOMMultiByte, (XPointer) text, length,
+				  overall_ink, overall_logical);
+}
+
+int
+_XwcGenericTextExtents(XOC oc, _Xconst wchar_t *text, int length,
+		       XRectangle *overall_ink, XRectangle *overall_logical)
+{
+    return _XomGenericTextExtents(oc, XOMWideChar, (XPointer) text, length,
+				  overall_ink, overall_logical);
+}
+
+int
+_Xutf8GenericTextExtents(XOC oc, _Xconst char *text, int length,
+			 XRectangle *overall_ink, XRectangle *overall_logical)
+{
+    return _XomGenericTextExtents(oc, XOMUtf8String, (XPointer) text, length,
+				  overall_ink, overall_logical);
+}
diff --git a/libX11/modules/om/generic/omTextPer.c b/libX11/modules/om/generic/omTextPer.c
index c66848aa2..ae08fe6a4 100644
--- a/libX11/modules/om/generic/omTextPer.c
+++ b/libX11/modules/om/generic/omTextPer.c
@@ -1,202 +1,202 @@
-/*

- * Copyright 1992, 1993 by TOSHIBA Corp.

- *

- * Permission to use, copy, modify, and distribute this software and its

- * documentation for any purpose and without fee is hereby granted, provided

- * that the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of TOSHIBA not be used in advertising

- * or publicity pertaining to distribution of the software without specific,

- * written prior permission. TOSHIBA make no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- *

- * Author: Katsuhisa Yano	TOSHIBA Corp.

- *			   	mopi@osa.ilab.toshiba.co.jp

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XomGeneric.h"

-#include <stdio.h>

-

-static Status

-_XomGenericTextPerCharExtents(

-    XOC oc,

-    XOMTextType type,

-    XPointer text,

-    int length,

-    XRectangle *ink_buf,

-    XRectangle *logical_buf,

-    int buf_size,

-    int *num_chars,

-    XRectangle *overall_ink,

-    XRectangle *overall_logical)

-{

-    XlcConv conv;

-    XFontStruct *font;

-    Bool is_xchar2b;

-    XPointer args[2];

-    XChar2b xchar2b_buf[BUFSIZ], *xchar2b_ptr;

-    char *xchar_ptr = NULL;

-    XCharStruct *def, *cs, overall;

-    int buf_len, left, require_num;

-    int logical_ascent, logical_descent;

-    Bool first = True;

-

-    conv = _XomInitConverter(oc, type);

-    if (conv == NULL)

-	return 0;

-

-    bzero((char *) &overall, sizeof(XCharStruct));

-    logical_ascent = logical_descent = require_num = *num_chars = 0;

-

-    args[0] = (XPointer) &font;

-    args[1] = (XPointer) &is_xchar2b;

-

-    while (length > 0) {

-	xchar2b_ptr = xchar2b_buf;

-	left = buf_len = BUFSIZ;

-

-	if (_XomConvert(oc, conv, (XPointer *) &text, &length,

-			(XPointer *) &xchar2b_ptr, &left, args, 2) < 0)

-	    break;

-	buf_len -= left;

-

-	if (require_num) {

-	    require_num += buf_len;

-	    continue;

-	}

-	if (buf_size < buf_len) {

-	    require_num = *num_chars + buf_len;

-	    continue;

-	}

-	buf_size -= buf_len;

-

-	if (first) {

-	    logical_ascent = font->ascent;

-	    logical_descent = font->descent;

-	} else {

-	    logical_ascent = max(logical_ascent, font->ascent);

-	    logical_descent = max(logical_descent, font->descent);

-	}

-

-	if (is_xchar2b) {

-	    CI_GET_DEFAULT_INFO_2D(font, def)

-	    xchar2b_ptr = xchar2b_buf;

-	} else {

-	    CI_GET_DEFAULT_INFO_1D(font, def)

-	    xchar_ptr = (char *) xchar2b_buf;

-	}

-

-	while (buf_len-- > 0) {

-	    if (is_xchar2b) {

-		CI_GET_CHAR_INFO_2D(font, xchar2b_ptr->byte1,

-				    xchar2b_ptr->byte2, def, cs)

-		xchar2b_ptr++;

-	    } else {

-		CI_GET_CHAR_INFO_1D(font, *xchar_ptr, def, cs)

-		xchar_ptr++;

-	    }

-	    if (cs == NULL)

-		continue;

-

-	    ink_buf->x = overall.width + cs->lbearing;

-	    ink_buf->y = -(cs->ascent);

-	    ink_buf->width = cs->rbearing - cs->lbearing;

-	    ink_buf->height = cs->ascent + cs->descent;

-	    ink_buf++;

-

-	    logical_buf->x = overall.width;

-	    logical_buf->y = -(font->ascent);

-	    logical_buf->width = cs->width;

-	    logical_buf->height = font->ascent + font->descent;

-	    logical_buf++;

-

-	    if (first) {

-		overall = *cs;

-		first = False;

-	    } else {

-		overall.ascent = max(overall.ascent, cs->ascent);

-		overall.descent = max(overall.descent, cs->descent);

-		overall.lbearing = min(overall.lbearing,

-				       overall.width + cs->lbearing);

-		overall.rbearing = max(overall.rbearing,

-				       overall.width + cs->rbearing);

-		overall.width += cs->width;

-	    }

-

-	    (*num_chars)++;

-	}

-    }

-

-    if (require_num) {

-	*num_chars = require_num;

-	return 0;

-    } else {

-	if (overall_ink) {

-	    overall_ink->x = overall.lbearing;

-	    overall_ink->y = -(overall.ascent);

-	    overall_ink->width = overall.rbearing - overall.lbearing;

-	    overall_ink->height = overall.ascent + overall.descent;

-	}

-

-	if (overall_logical) {

-	    overall_logical->x = 0;

-	    overall_logical->y = -(logical_ascent);

-	    overall_logical->width = overall.width;

-	    overall_logical->height = logical_ascent + logical_descent;

-	}

-    }

-

-    return 1;

-}

-

-Status

-_XmbGenericTextPerCharExtents(XOC oc, _Xconst char *text, int length,

-			      XRectangle *ink_buf, XRectangle *logical_buf,

-			      int buf_size, int *num_chars,

-			      XRectangle *overall_ink,

-			      XRectangle *overall_logical)

-{

-    return _XomGenericTextPerCharExtents(oc, XOMMultiByte, (XPointer) text,

-					 length, ink_buf, logical_buf, buf_size,

-					 num_chars, overall_ink,

-					 overall_logical);

-}

-

-Status

-_XwcGenericTextPerCharExtents(XOC oc, _Xconst wchar_t *text, int length,

-			      XRectangle *ink_buf, XRectangle *logical_buf,

-			      int buf_size, int *num_chars,

-			      XRectangle *overall_ink,

-			      XRectangle *overall_logical)

-{

-    return _XomGenericTextPerCharExtents(oc, XOMWideChar, (XPointer) text,

-					 length, ink_buf, logical_buf, buf_size,

-					 num_chars, overall_ink,

-					 overall_logical);

-}

-

-Status

-_Xutf8GenericTextPerCharExtents(XOC oc, _Xconst char *text, int length,

-				XRectangle *ink_buf, XRectangle *logical_buf,

-				int buf_size, int *num_chars,

-				XRectangle *overall_ink,

-				XRectangle *overall_logical)

-{

-    return _XomGenericTextPerCharExtents(oc, XOMUtf8String, (XPointer) text,

-					 length, ink_buf, logical_buf, buf_size,

-					 num_chars, overall_ink,

-					 overall_logical);

-}

+/*
+ * Copyright 1992, 1993 by TOSHIBA Corp.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of TOSHIBA not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission. TOSHIBA make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * Author: Katsuhisa Yano	TOSHIBA Corp.
+ *			   	mopi@osa.ilab.toshiba.co.jp
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XomGeneric.h"
+#include <stdio.h>
+
+static Status
+_XomGenericTextPerCharExtents(
+    XOC oc,
+    XOMTextType type,
+    XPointer text,
+    int length,
+    XRectangle *ink_buf,
+    XRectangle *logical_buf,
+    int buf_size,
+    int *num_chars,
+    XRectangle *overall_ink,
+    XRectangle *overall_logical)
+{
+    XlcConv conv;
+    XFontStruct *font;
+    Bool is_xchar2b;
+    XPointer args[2];
+    XChar2b xchar2b_buf[BUFSIZ], *xchar2b_ptr;
+    char *xchar_ptr = NULL;
+    XCharStruct *def, *cs, overall;
+    int buf_len, left, require_num;
+    int logical_ascent, logical_descent;
+    Bool first = True;
+
+    conv = _XomInitConverter(oc, type);
+    if (conv == NULL)
+	return 0;
+
+    bzero((char *) &overall, sizeof(XCharStruct));
+    logical_ascent = logical_descent = require_num = *num_chars = 0;
+
+    args[0] = (XPointer) &font;
+    args[1] = (XPointer) &is_xchar2b;
+
+    while (length > 0) {
+	xchar2b_ptr = xchar2b_buf;
+	left = buf_len = BUFSIZ;
+
+	if (_XomConvert(oc, conv, (XPointer *) &text, &length,
+			(XPointer *) &xchar2b_ptr, &left, args, 2) < 0)
+	    break;
+	buf_len -= left;
+
+	if (require_num) {
+	    require_num += buf_len;
+	    continue;
+	}
+	if (buf_size < buf_len) {
+	    require_num = *num_chars + buf_len;
+	    continue;
+	}
+	buf_size -= buf_len;
+
+	if (first) {
+	    logical_ascent = font->ascent;
+	    logical_descent = font->descent;
+	} else {
+	    logical_ascent = max(logical_ascent, font->ascent);
+	    logical_descent = max(logical_descent, font->descent);
+	}
+
+	if (is_xchar2b) {
+	    CI_GET_DEFAULT_INFO_2D(font, def)
+	    xchar2b_ptr = xchar2b_buf;
+	} else {
+	    CI_GET_DEFAULT_INFO_1D(font, def)
+	    xchar_ptr = (char *) xchar2b_buf;
+	}
+
+	while (buf_len-- > 0) {
+	    if (is_xchar2b) {
+		CI_GET_CHAR_INFO_2D(font, xchar2b_ptr->byte1,
+				    xchar2b_ptr->byte2, def, cs)
+		xchar2b_ptr++;
+	    } else {
+		CI_GET_CHAR_INFO_1D(font, *xchar_ptr, def, cs)
+		xchar_ptr++;
+	    }
+	    if (cs == NULL)
+		continue;
+
+	    ink_buf->x = overall.width + cs->lbearing;
+	    ink_buf->y = -(cs->ascent);
+	    ink_buf->width = cs->rbearing - cs->lbearing;
+	    ink_buf->height = cs->ascent + cs->descent;
+	    ink_buf++;
+
+	    logical_buf->x = overall.width;
+	    logical_buf->y = -(font->ascent);
+	    logical_buf->width = cs->width;
+	    logical_buf->height = font->ascent + font->descent;
+	    logical_buf++;
+
+	    if (first) {
+		overall = *cs;
+		first = False;
+	    } else {
+		overall.ascent = max(overall.ascent, cs->ascent);
+		overall.descent = max(overall.descent, cs->descent);
+		overall.lbearing = min(overall.lbearing,
+				       overall.width + cs->lbearing);
+		overall.rbearing = max(overall.rbearing,
+				       overall.width + cs->rbearing);
+		overall.width += cs->width;
+	    }
+
+	    (*num_chars)++;
+	}
+    }
+
+    if (require_num) {
+	*num_chars = require_num;
+	return 0;
+    } else {
+	if (overall_ink) {
+	    overall_ink->x = overall.lbearing;
+	    overall_ink->y = -(overall.ascent);
+	    overall_ink->width = overall.rbearing - overall.lbearing;
+	    overall_ink->height = overall.ascent + overall.descent;
+	}
+
+	if (overall_logical) {
+	    overall_logical->x = 0;
+	    overall_logical->y = -(logical_ascent);
+	    overall_logical->width = overall.width;
+	    overall_logical->height = logical_ascent + logical_descent;
+	}
+    }
+
+    return 1;
+}
+
+Status
+_XmbGenericTextPerCharExtents(XOC oc, _Xconst char *text, int length,
+			      XRectangle *ink_buf, XRectangle *logical_buf,
+			      int buf_size, int *num_chars,
+			      XRectangle *overall_ink,
+			      XRectangle *overall_logical)
+{
+    return _XomGenericTextPerCharExtents(oc, XOMMultiByte, (XPointer) text,
+					 length, ink_buf, logical_buf, buf_size,
+					 num_chars, overall_ink,
+					 overall_logical);
+}
+
+Status
+_XwcGenericTextPerCharExtents(XOC oc, _Xconst wchar_t *text, int length,
+			      XRectangle *ink_buf, XRectangle *logical_buf,
+			      int buf_size, int *num_chars,
+			      XRectangle *overall_ink,
+			      XRectangle *overall_logical)
+{
+    return _XomGenericTextPerCharExtents(oc, XOMWideChar, (XPointer) text,
+					 length, ink_buf, logical_buf, buf_size,
+					 num_chars, overall_ink,
+					 overall_logical);
+}
+
+Status
+_Xutf8GenericTextPerCharExtents(XOC oc, _Xconst char *text, int length,
+				XRectangle *ink_buf, XRectangle *logical_buf,
+				int buf_size, int *num_chars,
+				XRectangle *overall_ink,
+				XRectangle *overall_logical)
+{
+    return _XomGenericTextPerCharExtents(oc, XOMUtf8String, (XPointer) text,
+					 length, ink_buf, logical_buf, buf_size,
+					 num_chars, overall_ink,
+					 overall_logical);
+}
diff --git a/libX11/modules/om/generic/omXChar.c b/libX11/modules/om/generic/omXChar.c
index 61c8c0b89..ff517d5e5 100644
--- a/libX11/modules/om/generic/omXChar.c
+++ b/libX11/modules/om/generic/omXChar.c
@@ -1,477 +1,477 @@
-/*

- * Copyright 1992, 1993 by TOSHIBA Corp.

- *

- * Permission to use, copy, modify, and distribute this software and its

- * documentation for any purpose and without fee is hereby granted, provided

- * that the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of TOSHIBA not be used in advertising

- * or publicity pertaining to distribution of the software without specific,

- * written prior permission. TOSHIBA make no representations about the

- * suitability of this software for any purpose.  It is provided "as is"

- * without express or implied warranty.

- *

- * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

- * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

- * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

- * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

- * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- *

- * Author: Katsuhisa Yano	TOSHIBA Corp.

- *			   	mopi@osa.ilab.toshiba.co.jp

- */

-/*

- * Copyright 1995 by FUJITSU LIMITED

- * This is source code modified by FUJITSU LIMITED under the Joint

- * Development Agreement for the CDE/Motif PST.

- *

- * Modifier: Takanori Tateno   FUJITSU LIMITED

- *

- */

-/*

- * Modifiers: Jeff Walls, Paul Anderson (HEWLETT-PACKARD)

- */

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include "XlcPublic.h"

-#include "XomGeneric.h"

-#include <stdio.h>

-

-/* for VW/UDC start */

-static Bool

-ismatch_scopes(

-    FontData      fontdata,

-    unsigned long *value,

-    Bool	  is_shift)

-{

-    register int scopes_num = fontdata->scopes_num;

-    FontScope scopes = fontdata->scopes;

-    if (!scopes_num)

-        return False;

-

-    if(fontdata->font == NULL)

-	return False;

-

-    for(;scopes_num--;scopes++)

-        if ((scopes->start <= (*value & 0x7f7f)) &&

-                        ((scopes->end) >= (*value & 0x7f7f))){

-	    if(is_shift == True) {

-                if(scopes->shift){

-                    if(scopes->shift_direction == '+'){

-                        *value += scopes->shift ;

-                    } else if( scopes->shift_direction == '-'){

-                        *value -= scopes->shift ;

-                    }

-                }

-            }

-            return True;

-        }

-

-    return False;

-}

-

-static int

-check_vertical_fonttype(

-    char	*name)

-{

-    char	*ptr;

-    int		type = 0;

-

-    if(name == (char *)NULL || (int) strlen(name) <= 0)

-	return False;

-

-    /* Obtains the pointer of CHARSET_ENCODING_FIELD. */

-    if((ptr = strchr(name, '-')) == (char *) NULL)

-	return False;

-    ptr++;

-

-    /* Obtains the pointer of vertical_map font type. */

-    if((ptr = strchr(ptr, '.')) == (char *) NULL)

-	return False;

-    ptr++;

-

-    switch(*ptr) {

-      case '1':

-	type = 1;	break;

-      case '2':

-	type = 2;	break;

-      case '3':

-	type = 3;	break;

-    }

-    return type;

-}

-

-/*

-*/

-#define VMAP          0

-#define VROTATE       1

-#define FONTSCOPE     2

-

-FontData

-_XomGetFontDataFromFontSet(

-    FontSet fs,

-    unsigned char *str,

-    int len,

-    int *len_ret,

-    int is2b,

-    int type)          /* VMAP , VROTATE , else */

-{

-    unsigned long value;

-    int num,i,hit,csize;

-    FontData fontdata;

-    unsigned char *c;

-    int vfont_type;

-

-    c = str;

-    hit = -1;

-    if(type == VMAP){

-	fontdata = fs->vmap;

-	num      = fs->vmap_num;

-    } else if(type == VROTATE){

-        fontdata = (FontData)fs->vrotate;

-	num      = fs->vrotate_num;

-    } else {

-	if(fs->font_data_count <= 0 || fs->font_data == (FontData)NULL) {

-	    fontdata = fs->substitute;

-	    num      = fs->substitute_num;

-	}else {

-            fontdata = fs->font_data;

-	    num      = fs->font_data_count;

-	}

-	/* CDExc20229 fix */

-	if(fontdata == NULL || num == 0){

-	    return(NULL);

-	}

-    }

-

-

-    if(is2b){

-        csize = 2;

-    } else {

-        csize = 1;

-    }

-

-    for(;len;len--){

-        if(is2b){

-            value = (((unsigned long)*c) << 8)|(unsigned long)*(c + 1);

-        } else {

-            value = (unsigned long)*c;

-        }

-

-       /* ### NOTE: This routine DOES NOT WORK!

-	* ###       We can work around the problem in the calling routine,

-	* ###       but we really need to understand this better.  As it

-	* ###       stands, the algorithm ALWAYS returns "fontdata[0]"

-	* ###       for non-VW text!  This is clearly wrong.  In fact,

-	* ###       given the new parse_font[name|data]() algorithms,

-	* ###       we may not even need this routine to do anything

-	* ###       for non-VW text (since font_set->font always contains

-	* ###       the best font for this fontset).  -- jjw/pma (HP)

-	*/

-        for (i=0;i<num;i++) {

-	    if(type == VROTATE) {

-		if(fontdata[i].font) {

-		    /* If the num_cr equal zero, all character is rotated. */

-		    if(fontdata[i].scopes_num == 0) {

-			break;

-		    } else {

-			/* The vertical rotate glyph is not have code shift. */

-			if (ismatch_scopes(&(fontdata[i]),&value,False)) {

-			    break;

-			}

-		    }

-		}

-	    } else if(type == VMAP) {

-		if(fontdata[i].font) {

-		    vfont_type = check_vertical_fonttype(fontdata[i].name);

-		    if(vfont_type == 0 || vfont_type == 1) {

-			break;

-		    } else if(vfont_type == 2 || vfont_type == 3) {

-			if(fontdata[i].scopes_num <= 0)

-			    break;

-

-			if (ismatch_scopes(&(fontdata[i]),&value,True)) {

-			    break;

-			}

-		    }

-		}

-	    } else { /* FONTSCOPE */

-		if(fontdata[i].font) {

-		    if(fontdata[i].scopes_num <= 0)

-                        break;

-		    if (ismatch_scopes(&(fontdata[i]),&value,True)){

-		        break;

-                    }

-		}

-	    }

-        }

-        if((hit != -1) && (i != hit)){

-            break;

-        }

-        if(i == num){

-            if( type == VROTATE || type == VMAP){

-		/* Change 1996.01.23 start */

-		if(fs->font_data_count <= 0 ||

-		   fs->font_data == (FontData)NULL)

-		    fontdata = fs->substitute;

-		else

-		    fontdata = fs->font_data;

-		/* Change 1996.01.23 end */

-	    }

-	    hit = 0;

-            c += csize;

-	    break;

-        }

-        if( hit == -1 ) hit = i;

-        if(is2b){

-            *c = (unsigned char)(value >> 8);

-            *(c + 1) = (unsigned char)(value);

-        } else {

-            *c = (unsigned char)value;

-        }

-        c += csize;

-    }

-    *len_ret = (c - str);

-    return(&(fontdata[hit]));

-}

-/* for VW/UDC end   */

-

-static FontSet

-_XomGetFontSetFromCharSet(

-    XOC oc,

-    XlcCharSet charset)

-{

-    register FontSet font_set = XOC_GENERIC(oc)->font_set;

-    register int num = XOC_GENERIC(oc)->font_set_num;

-    XlcCharSet *charset_list;

-    int charset_count;

-

-    for ( ; num-- > 0; font_set++) {

-	charset_count = font_set->charset_count;

-	charset_list = font_set->charset_list;

-	for ( ; charset_count-- > 0; charset_list++)

-	    if (*charset_list == charset)

-		return font_set;

-    }

-

-    return (FontSet) NULL;

-}

-

-#ifdef MUSTCOPY

-static void

-cs_to_xchar2b(

-    register char *from,

-    register XChar2b *to,

-    register length)

-{

-    while (length-- > 0) {

-	to->byte1 = *from++;

-	to->byte2 = *from++;

-	to++;

-    }

-}

-

-static void

-cs_to_xchar2b_gl(

-    register char *from,

-    register XChar2b *to,

-    register length)

-{

-    while (length-- > 0) {

-	to->byte1 = *from++ & 0x7f;

-	to->byte2 = *from++ & 0x7f;

-	to++;

-    }

-}

-

-static void

-cs_to_xchar2b_gr(

-    register char *from,

-    register XChar2b *to,

-    register length)

-{

-    while (length-- > 0) {

-	to->byte1 = *from++ | 0x80;

-	to->byte2 = *from++ | 0x80;

-	to++;

-    }

-}

-#endif

-

-static void

-shift_to_gl(

-    register char *text,

-    register int length)

-{

-    while (length-- > 0)

-	*text++ &= 0x7f;

-}

-

-static void

-shift_to_gr(

-    register char *text,

-    register int length)

-{

-    while (length-- > 0)

-	*text++ |= 0x80;

-}

-

-static Bool

-load_font(

-    XOC oc,

-    FontSet font_set)

-{

-    font_set->font = XLoadQueryFont(oc->core.om->core.display,

-			oc->core.font_info.font_name_list[font_set->id]);

-    if (font_set->font == NULL)

-	return False;

-

-    oc->core.font_info.font_struct_list[font_set->id] = font_set->font;

-    XFreeFontInfo(NULL, font_set->info, 1);

-    font_set->info = NULL;

-

-    if (font_set->font->min_byte1 || font_set->font->max_byte1)

-	font_set->is_xchar2b = True;

-    else

-	font_set->is_xchar2b = False;

-

-    return True;

-}

-

-int

-_XomConvert(

-    XOC oc,

-    XlcConv conv,

-    XPointer *from,

-    int *from_left,

-    XPointer *to,

-    int *to_left,

-    XPointer *args,

-    int num_args)

-{

-    XPointer cs, lc_args[1];

-    XlcCharSet charset;

-    int length, cs_left, ret;

-    FontSet font_set;

-#ifdef MUSTCOPY

-    XChar2b *xchar2b;

-    char *buf, buf_local[BUFSIZ];

-#endif

-

-    cs = *to;

-    cs_left = *to_left;

-    lc_args[0] = (XPointer) &charset;

-

-    ret = _XlcConvert(conv, from, from_left, &cs, &cs_left, lc_args, 1);

-    if (ret < 0)

-	return -1;

-

-    font_set = _XomGetFontSetFromCharSet(oc, charset);

-    if (font_set == NULL)

-	return -1;

-

-    if (font_set->font == NULL && load_font(oc, font_set) == False)

-	return -1;

-

-    length = *to_left - cs_left;

-

-#ifdef MUSTCOPY

-    if (font_set->is_xchar2b) {

-	buf = (length > BUFSIZ) ? Xmalloc(length) : buf_local;

-	if (buf == NULL)

-	    return -1;

-	memcpy(buf, (char *) *to, length);

-

-	xchar2b = (XChar2b *) *to;

-	length >>= 1;

-

-	if (font_set->side == charset->side)

-	    cs_to_xchar2b(buf, xchar2b, length);

-	else if (font_set->side == XlcGL)

-	    cs_to_xchar2b_gl(buf, xchar2b, length);

-	else if (font_set->side == XlcGR)

-	    cs_to_xchar2b_gr(buf, xchar2b, length);

-	else

-	    cs_to_xchar2b(buf, xchar2b, length);

-

-	if (buf != buf_local)

-	    Xfree(buf);

-

-	*to = (XPointer) (xchar2b + length);

-	*to_left -= length;

-    } else

-#endif

-    {

-	if (font_set->side != charset->side) {

-	    if (font_set->side == XlcGL)

-		shift_to_gl(*to, length);

-	    else if (font_set->side == XlcGR)

-		shift_to_gr(*to, length);

-	}

-

-	if (font_set->is_xchar2b)

-	    length >>= 1;

-	*to = cs;

-	*to_left -= length;

-    }

-

-    *((XFontStruct **) args[0]) = font_set->font;

-    *((Bool *) args[1]) = font_set->is_xchar2b;

-    if(num_args >= 3){

-        *((FontSet *) args[2]) = font_set;

-    }

-

-    return ret;

-}

-

-XlcConv

-_XomInitConverter(

-    XOC oc,

-    XOMTextType type)

-{

-    XOCGenericPart *gen = XOC_GENERIC(oc);

-    XlcConv *convp;

-    const char *conv_type;

-    XlcConv conv;

-    XLCd lcd;

-

-    switch (type) {

-    case XOMWideChar:

-	convp = &gen->wcs_to_cs;

-	conv_type = XlcNWideChar;

-	break;

-    case XOMMultiByte:

-	convp = &gen->mbs_to_cs;

-	conv_type = XlcNMultiByte;

-	break;

-    case XOMUtf8String:

-	convp = &gen->utf8_to_cs;

-	conv_type = XlcNUtf8String;

-	break;

-    default:

-	return (XlcConv) NULL;

-    }

-

-    conv = *convp;

-    if (conv) {

-	_XlcResetConverter(conv);

-	return conv;

-    }

-

-    lcd = oc->core.om->core.lcd;

-

-    conv = _XlcOpenConverter(lcd, conv_type, lcd, XlcNFontCharSet);

-    if (conv == (XlcConv) NULL) {

-        conv = _XlcOpenConverter(lcd, conv_type, lcd, XlcNCharSet);

-        if (conv == (XlcConv) NULL)

-	    return (XlcConv) NULL;

-    }

-

-    *convp = conv;

-    return conv;

-}

+/*
+ * Copyright 1992, 1993 by TOSHIBA Corp.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of TOSHIBA not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission. TOSHIBA make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+ * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ *
+ * Author: Katsuhisa Yano	TOSHIBA Corp.
+ *			   	mopi@osa.ilab.toshiba.co.jp
+ */
+/*
+ * Copyright 1995 by FUJITSU LIMITED
+ * This is source code modified by FUJITSU LIMITED under the Joint
+ * Development Agreement for the CDE/Motif PST.
+ *
+ * Modifier: Takanori Tateno   FUJITSU LIMITED
+ *
+ */
+/*
+ * Modifiers: Jeff Walls, Paul Anderson (HEWLETT-PACKARD)
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "XlcPublic.h"
+#include "XomGeneric.h"
+#include <stdio.h>
+
+/* for VW/UDC start */
+static Bool
+ismatch_scopes(
+    FontData      fontdata,
+    unsigned long *value,
+    Bool	  is_shift)
+{
+    register int scopes_num = fontdata->scopes_num;
+    FontScope scopes = fontdata->scopes;
+    if (!scopes_num)
+        return False;
+
+    if(fontdata->font == NULL)
+	return False;
+
+    for(;scopes_num--;scopes++)
+        if ((scopes->start <= (*value & 0x7f7f)) &&
+                        ((scopes->end) >= (*value & 0x7f7f))){
+	    if(is_shift == True) {
+                if(scopes->shift){
+                    if(scopes->shift_direction == '+'){
+                        *value += scopes->shift ;
+                    } else if( scopes->shift_direction == '-'){
+                        *value -= scopes->shift ;
+                    }
+                }
+            }
+            return True;
+        }
+
+    return False;
+}
+
+static int
+check_vertical_fonttype(
+    char	*name)
+{
+    char	*ptr;
+    int		type = 0;
+
+    if(name == (char *)NULL || (int) strlen(name) <= 0)
+	return False;
+
+    /* Obtains the pointer of CHARSET_ENCODING_FIELD. */
+    if((ptr = strchr(name, '-')) == (char *) NULL)
+	return False;
+    ptr++;
+
+    /* Obtains the pointer of vertical_map font type. */
+    if((ptr = strchr(ptr, '.')) == (char *) NULL)
+	return False;
+    ptr++;
+
+    switch(*ptr) {
+      case '1':
+	type = 1;	break;
+      case '2':
+	type = 2;	break;
+      case '3':
+	type = 3;	break;
+    }
+    return type;
+}
+
+/*
+*/
+#define VMAP          0
+#define VROTATE       1
+#define FONTSCOPE     2
+
+FontData
+_XomGetFontDataFromFontSet(
+    FontSet fs,
+    unsigned char *str,
+    int len,
+    int *len_ret,
+    int is2b,
+    int type)          /* VMAP , VROTATE , else */
+{
+    unsigned long value;
+    int num,i,hit,csize;
+    FontData fontdata;
+    unsigned char *c;
+    int vfont_type;
+
+    c = str;
+    hit = -1;
+    if(type == VMAP){
+	fontdata = fs->vmap;
+	num      = fs->vmap_num;
+    } else if(type == VROTATE){
+        fontdata = (FontData)fs->vrotate;
+	num      = fs->vrotate_num;
+    } else {
+	if(fs->font_data_count <= 0 || fs->font_data == (FontData)NULL) {
+	    fontdata = fs->substitute;
+	    num      = fs->substitute_num;
+	}else {
+            fontdata = fs->font_data;
+	    num      = fs->font_data_count;
+	}
+	/* CDExc20229 fix */
+	if(fontdata == NULL || num == 0){
+	    return(NULL);
+	}
+    }
+
+
+    if(is2b){
+        csize = 2;
+    } else {
+        csize = 1;
+    }
+
+    for(;len;len--){
+        if(is2b){
+            value = (((unsigned long)*c) << 8)|(unsigned long)*(c + 1);
+        } else {
+            value = (unsigned long)*c;
+        }
+
+       /* ### NOTE: This routine DOES NOT WORK!
+	* ###       We can work around the problem in the calling routine,
+	* ###       but we really need to understand this better.  As it
+	* ###       stands, the algorithm ALWAYS returns "fontdata[0]"
+	* ###       for non-VW text!  This is clearly wrong.  In fact,
+	* ###       given the new parse_font[name|data]() algorithms,
+	* ###       we may not even need this routine to do anything
+	* ###       for non-VW text (since font_set->font always contains
+	* ###       the best font for this fontset).  -- jjw/pma (HP)
+	*/
+        for (i=0;i<num;i++) {
+	    if(type == VROTATE) {
+		if(fontdata[i].font) {
+		    /* If the num_cr equal zero, all character is rotated. */
+		    if(fontdata[i].scopes_num == 0) {
+			break;
+		    } else {
+			/* The vertical rotate glyph is not have code shift. */
+			if (ismatch_scopes(&(fontdata[i]),&value,False)) {
+			    break;
+			}
+		    }
+		}
+	    } else if(type == VMAP) {
+		if(fontdata[i].font) {
+		    vfont_type = check_vertical_fonttype(fontdata[i].name);
+		    if(vfont_type == 0 || vfont_type == 1) {
+			break;
+		    } else if(vfont_type == 2 || vfont_type == 3) {
+			if(fontdata[i].scopes_num <= 0)
+			    break;
+
+			if (ismatch_scopes(&(fontdata[i]),&value,True)) {
+			    break;
+			}
+		    }
+		}
+	    } else { /* FONTSCOPE */
+		if(fontdata[i].font) {
+		    if(fontdata[i].scopes_num <= 0)
+                        break;
+		    if (ismatch_scopes(&(fontdata[i]),&value,True)){
+		        break;
+                    }
+		}
+	    }
+        }
+        if((hit != -1) && (i != hit)){
+            break;
+        }
+        if(i == num){
+            if( type == VROTATE || type == VMAP){
+		/* Change 1996.01.23 start */
+		if(fs->font_data_count <= 0 ||
+		   fs->font_data == (FontData)NULL)
+		    fontdata = fs->substitute;
+		else
+		    fontdata = fs->font_data;
+		/* Change 1996.01.23 end */
+	    }
+	    hit = 0;
+            c += csize;
+	    break;
+        }
+        if( hit == -1 ) hit = i;
+        if(is2b){
+            *c = (unsigned char)(value >> 8);
+            *(c + 1) = (unsigned char)(value);
+        } else {
+            *c = (unsigned char)value;
+        }
+        c += csize;
+    }
+    *len_ret = (c - str);
+    return(&(fontdata[hit]));
+}
+/* for VW/UDC end   */
+
+static FontSet
+_XomGetFontSetFromCharSet(
+    XOC oc,
+    XlcCharSet charset)
+{
+    register FontSet font_set = XOC_GENERIC(oc)->font_set;
+    register int num = XOC_GENERIC(oc)->font_set_num;
+    XlcCharSet *charset_list;
+    int charset_count;
+
+    for ( ; num-- > 0; font_set++) {
+	charset_count = font_set->charset_count;
+	charset_list = font_set->charset_list;
+	for ( ; charset_count-- > 0; charset_list++)
+	    if (*charset_list == charset)
+		return font_set;
+    }
+
+    return (FontSet) NULL;
+}
+
+#ifdef MUSTCOPY
+static void
+cs_to_xchar2b(
+    register char *from,
+    register XChar2b *to,
+    register length)
+{
+    while (length-- > 0) {
+	to->byte1 = *from++;
+	to->byte2 = *from++;
+	to++;
+    }
+}
+
+static void
+cs_to_xchar2b_gl(
+    register char *from,
+    register XChar2b *to,
+    register length)
+{
+    while (length-- > 0) {
+	to->byte1 = *from++ & 0x7f;
+	to->byte2 = *from++ & 0x7f;
+	to++;
+    }
+}
+
+static void
+cs_to_xchar2b_gr(
+    register char *from,
+    register XChar2b *to,
+    register length)
+{
+    while (length-- > 0) {
+	to->byte1 = *from++ | 0x80;
+	to->byte2 = *from++ | 0x80;
+	to++;
+    }
+}
+#endif
+
+static void
+shift_to_gl(
+    register char *text,
+    register int length)
+{
+    while (length-- > 0)
+	*text++ &= 0x7f;
+}
+
+static void
+shift_to_gr(
+    register char *text,
+    register int length)
+{
+    while (length-- > 0)
+	*text++ |= 0x80;
+}
+
+static Bool
+load_font(
+    XOC oc,
+    FontSet font_set)
+{
+    font_set->font = XLoadQueryFont(oc->core.om->core.display,
+			oc->core.font_info.font_name_list[font_set->id]);
+    if (font_set->font == NULL)
+	return False;
+
+    oc->core.font_info.font_struct_list[font_set->id] = font_set->font;
+    XFreeFontInfo(NULL, font_set->info, 1);
+    font_set->info = NULL;
+
+    if (font_set->font->min_byte1 || font_set->font->max_byte1)
+	font_set->is_xchar2b = True;
+    else
+	font_set->is_xchar2b = False;
+
+    return True;
+}
+
+int
+_XomConvert(
+    XOC oc,
+    XlcConv conv,
+    XPointer *from,
+    int *from_left,
+    XPointer *to,
+    int *to_left,
+    XPointer *args,
+    int num_args)
+{
+    XPointer cs, lc_args[1];
+    XlcCharSet charset;
+    int length, cs_left, ret;
+    FontSet font_set;
+#ifdef MUSTCOPY
+    XChar2b *xchar2b;
+    char *buf, buf_local[BUFSIZ];
+#endif
+
+    cs = *to;
+    cs_left = *to_left;
+    lc_args[0] = (XPointer) &charset;
+
+    ret = _XlcConvert(conv, from, from_left, &cs, &cs_left, lc_args, 1);
+    if (ret < 0)
+	return -1;
+
+    font_set = _XomGetFontSetFromCharSet(oc, charset);
+    if (font_set == NULL)
+	return -1;
+
+    if (font_set->font == NULL && load_font(oc, font_set) == False)
+	return -1;
+
+    length = *to_left - cs_left;
+
+#ifdef MUSTCOPY
+    if (font_set->is_xchar2b) {
+	buf = (length > BUFSIZ) ? Xmalloc(length) : buf_local;
+	if (buf == NULL)
+	    return -1;
+	memcpy(buf, (char *) *to, length);
+
+	xchar2b = (XChar2b *) *to;
+	length >>= 1;
+
+	if (font_set->side == charset->side)
+	    cs_to_xchar2b(buf, xchar2b, length);
+	else if (font_set->side == XlcGL)
+	    cs_to_xchar2b_gl(buf, xchar2b, length);
+	else if (font_set->side == XlcGR)
+	    cs_to_xchar2b_gr(buf, xchar2b, length);
+	else
+	    cs_to_xchar2b(buf, xchar2b, length);
+
+	if (buf != buf_local)
+	    Xfree(buf);
+
+	*to = (XPointer) (xchar2b + length);
+	*to_left -= length;
+    } else
+#endif
+    {
+	if (font_set->side != charset->side) {
+	    if (font_set->side == XlcGL)
+		shift_to_gl(*to, length);
+	    else if (font_set->side == XlcGR)
+		shift_to_gr(*to, length);
+	}
+
+	if (font_set->is_xchar2b)
+	    length >>= 1;
+	*to = cs;
+	*to_left -= length;
+    }
+
+    *((XFontStruct **) args[0]) = font_set->font;
+    *((Bool *) args[1]) = font_set->is_xchar2b;
+    if(num_args >= 3){
+        *((FontSet *) args[2]) = font_set;
+    }
+
+    return ret;
+}
+
+XlcConv
+_XomInitConverter(
+    XOC oc,
+    XOMTextType type)
+{
+    XOCGenericPart *gen = XOC_GENERIC(oc);
+    XlcConv *convp;
+    const char *conv_type;
+    XlcConv conv;
+    XLCd lcd;
+
+    switch (type) {
+    case XOMWideChar:
+	convp = &gen->wcs_to_cs;
+	conv_type = XlcNWideChar;
+	break;
+    case XOMMultiByte:
+	convp = &gen->mbs_to_cs;
+	conv_type = XlcNMultiByte;
+	break;
+    case XOMUtf8String:
+	convp = &gen->utf8_to_cs;
+	conv_type = XlcNUtf8String;
+	break;
+    default:
+	return (XlcConv) NULL;
+    }
+
+    conv = *convp;
+    if (conv) {
+	_XlcResetConverter(conv);
+	return conv;
+    }
+
+    lcd = oc->core.om->core.lcd;
+
+    conv = _XlcOpenConverter(lcd, conv_type, lcd, XlcNFontCharSet);
+    if (conv == (XlcConv) NULL) {
+        conv = _XlcOpenConverter(lcd, conv_type, lcd, XlcNCharSet);
+        if (conv == (XlcConv) NULL)
+	    return (XlcConv) NULL;
+    }
+
+    *convp = conv;
+    return conv;
+}