/**************************************************************************

*                   E X J D X G E N

*                                                   Author: Jim Breen

*

*   This is the Unix version of EJDXGEN, ported from MS-DOS

***************************************************************************/

/*  This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 1, or (at your option)

    any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     */

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

/*#include <stdlib.h>*/

#include <ctype.h>

#include <string.h>

#include "xjdic.h"

#define TRUE 1

#define FALSE 0

#define EXLIM 100

unsigned char *db;

unsigned char ENVname[50];

unsigned char *dicenv;

struct stat *buf;

unsigned long dbyte;

unsigned long  *jindex;

unsigned long indptr,llone,charno,recpos,charnost;

int State;

unsigned char Dname[80] = {"edictext"};

unsigned char JDXname[80] = {"edictext.xjdx"};

int jiver = 14;		/*The last time the index structure changed was Version1.4*/

/*====== prototypes=================================================*/

int stringcomp(unsigned char *s1, unsigned char *s2);

void jqsort(long i, long j);

int Kstrcmp(unsigned long lhs, unsigned long rhs);

/*====== end prototypes=================================================*/

int stringcomp(unsigned char *s1, unsigned char *s2)

{

	int i;

	unsigned char c1,c2;

	for(i = 0; i < strlen(s1);i++) 

	{

		c1 = s1[i];

		if (c1 < 0x60) c1 = (c1|0x20);

		c2 = s2[i];

		if (c2 < 0x60) c2 = (c2|0x20);

		if (c1 != c2) return(1);

	}

	return (0);

}

/*====function to Load Dictionary and load/create index table=======*/

main(argc,argv)

int argc;

unsigned char **argv;

{

  FILE *fp,*fopen();

  unsigned long schi,diclen,indlen;

  int i,inwd,saving,nodread;

  unsigned char c;

  unsigned char **ap;

  printf("\nEXJDXGEN V2.0 Extension Index Table Generator for XJDIC. \n      Copyright J.W. Breen, 1995\n");

  if (argc > 1)

  {

	ap = argv;

	ap++;

	if(strcmp(*ap,"-h") == 0)

	{

		printf("\nThere are two command-line options:\n");

		printf("  -h  this display\n");

		printf("  filename - file to be indexed\n\n");

		exit(0);

	}

	strcpy(Dname,*ap);

	strcpy(JDXname,*ap);

	strcat(JDXname,".xjdx");

    printf("Commandline request to use files %s and %s \n",Dname,JDXname);

  }

  inwd = FALSE;

  indptr = 1;

  llone = 1;

  buf = (void *)malloc(1000);

  if(stat(Dname, buf) != 0)

  {

	 perror(NULL);

	 printf("Cannot stat: %s \n",Dname);

	 exit(1);

  }

  diclen = buf->st_size;

  printf("\nWARNING!!  This program may take a long time to run .....\n");

  puts ("\nLoading Dictionary file.  Please wait.....\n");

  fp=fopen(Dname,"rb");

  if (fp==NULL )

  {

	printf("\nCannot open dictionary file\n");

	exit(1);

  }

  db = (unsigned char *)malloc((diclen+100) * sizeof(unsigned char));

  if(db == NULL)

  {

      fprintf(stderr,"malloc() for dictionary failed.\n");

      fclose(fp);

      exit(1);

  }

  nodread = diclen/1024;

  dbyte = fread((unsigned char *)db+1, 1024, nodread, fp);

  nodread = diclen % 1024;

  dbyte = fread((unsigned char *)(db+(diclen/1024)*1024)+1, nodread,1, fp);

  fclose(fp);

  diclen++;

  dbyte = diclen;

  db[diclen] = 10;

  db[0] = 10;

  printf("Dictionary size: %ld bytes.\n",dbyte);

  indlen = diclen / 2;

  jindex = (unsigned long *)malloc(indlen);

  if(jindex == NULL)

  {

	  fprintf(stderr,"malloc() for index table failed.\n");

	  fclose(fp);

	  exit(1);

  }

  printf("Parsing.... \n");

  indptr = 1;

  saving = FALSE;

  charno = -1;

  State = 0;

  for (schi =0; schi < dbyte; schi++) /* scan whole dictionary  */

  {

	  c = db[schi];

	  charno++;

	  if (c == 0x0a)

	  {

		recpos = charno+1;

		continue;

	  }

	  switch (State)

	  {

	  case 0 :	/* Looking for < 	*/

		if (c == '<') State = 1;

		break;

	  case 1 :	/* Inside <..>, but nothing started yet	*/

		if (c >= 127)

		{

			saving = TRUE;

			charnost = charno-1;

			State = 2;

			break;

		}

		else

		{

			State = 3;

	  		schi--;

	  		charno--;

			break;

		}

	case 2 :	/* storing keywords  */

		if (c >= 127)

		{

			break;

		}

		else

		{

			jindex[indptr] = charnost;

			jindex[indptr+1] = recpos;

			indptr+=2;

			if (indptr > indlen/sizeof(long))

			{

			  	printf("Index table overflow. Dictionary too large?\n");

			  	exit(1);

			}

			saving = FALSE;

	  		schi--;

	  		charno--;

			State = 3;

			break;

		}

	case 3 : 	/* encountered non-JIS	*/

		if (c == '>')

		{

			State = 0;

			break;

		}

		if (c == '[')

		{

			State = 4;

			break;

		}

		if (c >= 127)

		{

			schi--;

  			charno--;

			State = 1;

		}

		break;

	case 4 :	/* skip all until ]		*/

		if (c == ']') State = 1;

		break;

	}

    }

    indptr-=2;

    printf("Index entries: %ld  \nSorting (this is slow)......\n",indptr);

    jqsort(llone,(indptr/2)+1);

    printf("Sorted\nWriting index file ....\n");

    fp = fopen(JDXname,"wb");

    if (fp==NULL )

    {

    	printf("\nCannot open %s output file\n",JDXname);

    	exit(1);

    }

  jindex[0] = diclen+jiver;

  fwrite(jindex,sizeof(long),indptr+2,fp);

  fclose(fp);

}

/*======function to sort jindex table====================*/

void jqsort(long lhsr, long rhsr)

{

	long i,last,midp,lhs,rhs;

	unsigned long temp,temp2;

	lhs = ((lhsr-1)*2)+1;

	rhs = ((rhsr-1)*2)+1;

	if (lhs >= rhs) return;

	/* Swap ( lhs , (lhs+rhs)/2);*/

	midp = (lhs+rhs)/2;

	if (!(midp & 1)) midp--;

	temp = jindex[lhs];

	temp2 = jindex[lhs+1];

	jindex[lhs] = jindex[midp];

	jindex[lhs+1] = jindex[midp+1];

	jindex[midp] = temp;

	jindex[midp+1] = temp2;

	last = lhs;

	for (i = lhs+2;i <= rhs; i+=2)

		{

			if (Kstrcmp(jindex[i],jindex[lhs]) < 0)

			{

				/* Swap(++last,i);*/

				last+=2;

				temp = jindex[i];

				jindex[i] = jindex[last];

				jindex[last] = temp;

				temp = jindex[i+1];

				jindex[i+1] = jindex[last+1];

				jindex[last+1] = temp;

			}

		}

/*	Swap (lhs,last);*/

	temp = jindex[lhs];

	jindex[lhs] = jindex[last];

	jindex[last] = temp;

	temp = jindex[lhs+1];

	jindex[lhs+1] = jindex[last+1];

	jindex[last+1] = temp;

	jqsort((lhs/2)+1,last/2);

	jqsort((last/2)+2,(rhs/2)+1);

}

/*=====string comparison used by jqsort==========================*/

int Kstrcmp(unsigned long lhs, unsigned long rhs)

{

	int i,c1,c2;

/* effectively does a strnicmp on two "strings" within the dictionary,

   except it will make katakana and hirgana match (EUC A4 & A5) */

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

	{

		c1 = db[lhs+i+1];

		c2 = db[rhs+i+1];

		if ((i % 2) == 0)

		{

			if (c1 == 0xA5)

			{

				c1 = 0xA4;

			}

			if (c2 == 0xA5)

			{

				c2 = 0xA4;

			}

		}

		if ((c1 >= 'A') && (c1 <= 'Z')) c1 |= 0x20;

		if ((c2 >= 'A') && (c2 <= 'Z')) c2 |= 0x20;

		if (c1 != c2 ) break;

	}

	return(c1-c2);

}

########################################################################

#

#       X J D I C

#

#######################################################################

# This is the makefile for xjdic/xjdserver/xjdxgen V2.4

# 

# to use this file, you have several options:

#	make all - does all the binaries

#	make client - just makes the xjdic_cl binary

#	make server - just makes the xjdserver server

#	make stand - just makes the xjdic_sa stand-alone version

#	make xjdxgen - just makes the xjdxgen index generator

#	make exjdxgen - just makes the exjdxgen extension file index generator

#	make clean - just tidies up, removing the .o files.

#	make realclean - deletes everything compiled, not just .o files.

#

#	This Makefile is set to use the gcc compiler. If you want cc instead

#	you will need to alter the "CC=gcc" below, or use CC=cc on the command 

#	line.

#

#	If you want strict BSD ioctls used (which seems to be the case

#	for Suns) add -D__STRICT_BSD___ to the SACFLAGS and CLCFLAGS macros.

#

#	You need to select one of three dictionary and index file

#	access options by uncommenting the appropriate SACFLAGS and

#	SVCFLAGS macros:

#

#		memory-mapped I/O	use -DMMAP

#		demand-paging		use -DDEMAND_PAGING

#		load into RAM		use -DRAM_LOAD

#

#	Memory-mapped I/O does not appear to function correctly

#	under Ultrix. It works with Solaris and Linux.

#

#	Note that it is assumed that window-size ioctls are available.

#	If you want to use curses instead, delete the -DWINSIZE....,

#	and compile the client and/or the stand-alone programs with

#	the "-lcurses -ltermcap".

#

#	Expect some compilation warnings about "qsort". No-one seems

#	able to remove them.

#

#	For DEC Ultrix, you will probably need to alter the comments

#	on the SACFLAGS and SVCFLAGS macros to remove MMAP, as this

#	appears not to work on that OS.

#

#	For Sun and Linux, you may need to include the "unistd.h" file.

#

#	For Solaris 2.x, you will probably need to uncomment the following

#	if you want to use the server/client operation. Also be prepared

#	for some complaining about pointer mismatches in routines like

#	`recv'. They can be ignored.

#

#LIBS= -lsocket -lnsl

#

CC=gcc -g

all: xjdic_sa xjdic_cl xjdserver xjdxgen exjdxgen

client: xjdic_cl

server: xjdserver

stand: xjdic_sa

#

#	X J D X G E N

#

JDXOBJECTS = xjdxgen.o

xjdxgen: $(JDXOBJECTS)

	$(CC) $(JDXOBJECTS) -o xjdxgen

xjdxgen.o:	xjdxgen.c

	$(CC) -c xjdxgen.c

#

#	E X J D X G E N

#

EJDXOBJECTS = exjdxgen.o

exjdxgen: $(EJDXOBJECTS)

	$(CC) $(EJDXOBJECTS) -o exjdxgen

exjdxgen.o:	exjdxgen.c

	$(CC) -c exjdxgen.c

#

#	S T A N D _ A L O N E 

#

SAOBJECTS = xjdsa.o xjdcomm_sa.o xjdservcomm_sa.o xjdfrontend_sa.o

#SACFLAGS = -DXJDFRONTEND -DXJDDIC -DDEMAND_PAGING

SACFLAGS = -DXJDFRONTEND -DXJDDIC -DMMAP

#SACFLAGS = -DXJDFRONTEND -DXJDDIC -DRAM_LOAD

xjdic_sa: $(SAOBJECTS)

	$(CC) $(SAOBJECTS) -o xjdic_sa

xjdsa.o: xjdsa.c

	$(CC) -c $(SACFLAGS) xjdsa.c

xjdcomm_sa.o: xjdcomm.c

	$(CC) -c $(SACFLAGS) xjdcomm.c -o xjdcomm_sa.o

xjdservcomm_sa.o: xjdservcomm.c

	$(CC) -c $(SACFLAGS) xjdservcomm.c -o xjdservcomm_sa.o

xjdfrontend_sa.o: xjdfrontend.c

	$(CC) -c $(SACFLAGS) xjdfrontend.c -o xjdfrontend_sa.o

$(SAOBJECTS): xjdic.h

#

#	C L I E N T

#

CLOBJECTS = xjdclient.o xjdcomm_cl.o xjdfrontend_cl.o

CLCFLAGS = -DXJDFRONTEND -DXJDCLSERV

xjdic_cl: $(CLOBJECTS)

	$(CC) $(CLOBJECTS) $(LIBS) -o xjdic_cl

xjdclient.o: xjdclient.c

	$(CC) -c $(CLCFLAGS) xjdclient.c

xjdcomm_cl.o: xjdcomm.c

	$(CC) -c $(CLCFLAGS) xjdcomm.c -o xjdcomm_cl.o

xjdfrontend_cl.o: xjdfrontend.c

	$(CC) -c $(CLCFLAGS) xjdfrontend.c -o xjdfrontend_cl.o

$(CLOBJECTS): xjdic.h

#

#	S E R V E R

#

SVOBJECTS = xjdcomm_sv.o xjdservcomm_sv.o xjdserver.o

#SVCFLAGS = -DXJDDIC -DXJDCLSERV -DDEMAND_PAGING

SVCFLAGS = -DXJDDIC -DXJDCLSERV -DMMAP

#SVCFLAGS = -DXJDDIC -DXJDCLSERV -DRAM_LOAD

xjdserver: $(SVOBJECTS)

	$(CC) $(SVOBJECTS) $(LIBS) -o xjdserver

xjdcomm_sv.o: xjdcomm.c

	$(CC) -c $(SVCFLAGS) xjdcomm.c -o xjdcomm_sv.o

xjdservcomm_sv.o: xjdservcomm.c

	$(CC) -c $(SVCFLAGS) xjdservcomm.c -o xjdservcomm_sv.o

xjdserver.o: xjdserver.c

	$(CC) -c $(SVCFLAGS) xjdserver.c 

$(SVOBJECTS): xjdic.h

#

clean:

	rm -f *.o

realclean: clean

	rm -f xjdic_sa xjdic_cl xjdserver xjdxgen exjdxgen

#

#    This program is free software; you can redistribute it and/or modify

#    it under the terms of the GNU General Public License as published by

#    the Free Software Foundation; either version 1, or (at your option)

#    any later version.

#

#    This program is distributed in the hope that it will be useful,

#    but WITHOUT ANY WARRANTY; without even the implied warranty of

#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#    GNU General Public License for more details.

#

#    You should have received a copy of the GNU General Public License

#    along with this program; if not, write to the Free Software

#    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     */

#include <errno.h>

/**************************************************************************

*                 X  J  D  C  L  I  E  N  T                               *     *

*              Code  for Interfacing the Client with the server           *

*         Japanese-English Dictionary program (X11 version)               *

*                                                   Author: Jim Breen     *

***************************************************************************/

/*  This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 1, or (at your option)

    any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     */

/* for Solaris 2.5, which doesn't have INADDR_NONE in its <netinet/in.h> */

#ifdef SOLARIS

#define INADDR_NONE -1

#endif

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <stdlib.h>

#include <unistd.h>

#include <signal.h>

#include <errno.h>

#include "xjdic.h"

#define CVERBOSE 0

int chk_cnt=0;

unsigned char host[51] = {"localhost"};

unsigned char yn[2];

unsigned int portno = XJ_PORTNO;

char protocol[4] = {"udp"};

int s, elapse;

struct timeval timeout;

int txno = 0;

REQ_PDU pdu_out;

RSP_PDU pdu_in;

int pduseq = 0;

int curr_timer = TINITVAL;

int rep_count;

struct timezone tz;

long timeofday_st,timeofday_en;

fd_set fildesc;

int nfds;

unsigned char *sptr;

int NoDics,CurrDic;

char Dnamet[10][100];

void xjdserver (int type, int dic_no, long index_posn, int sch_str_len,

                unsigned char *sch_str, int *sch_resp, long *res_index, 

                int *hit_posn, int *res_len, unsigned char *res_str,

                long *dic_loc );

void DicSet();

int connectsock(int portno, char *host);

void reqchecksum();

int respchecksum();

void DicSet()

{

/*	In the Client version, DicSet() establishes the connection with 

	the server. */

	int i,schresp, dumint, trying,hullodic;

	long dumlong,dumlong0 = 0;

	char dummy[2],dnamelist[512];

	connectsock(portno, host);

	nfds = getdtablesize();

	FD_SET(s, &fildesc);

	trying = TRUE;

	while (trying)

	{

		xjdserver(XJ_HULLO, 0, dumlong0, 0, dummy, &schresp, &dumlong, 

			&hullodic, &dumint, dnamelist, &dumlong);

		if (schresp == XJ_OK) 

		{

			printf("Server: %s detected\n", host);

			NoDics = hullodic;

			sptr = strtok(dnamelist,"#");

			while (sptr != NULL)

			{

				i = sptr[0] - '0';

				if (i <= NoDics) 

				{

					strcpy(Dnamet[i],sptr+1);

					printf ("Dictionary: %d [%s]\n",i,Dnamet[i]);

				}

				sptr = strtok(NULL,"#");

			}

			CurrDic = 1;

			return;

		}

		printf("Server not responding.(%d) Try again? (y/n)",schresp);

		scanf("%c",dummy);

		printf("\n");

		if ((dummy[0] | 0x20) == 'n') exit(1);

	}

}

int connectsock(int portno, char *host)

{

	struct protoent *ppe;

	struct hostent *phe;

	struct sockaddr_in sin;

	bzero((char *)&sin, sizeof(sin));

	sin.sin_family = AF_INET;

	sin.sin_port = htons(portno);

	if (phe = gethostbyname(host))

		bcopy(phe->h_addr, (char *)&sin.sin_addr, phe->h_length);

	else if ((sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE)

	{

		printf ("Cannot Get Host Entry!!\n");

		exit(1);

	}

	if ((ppe = getprotobyname("udp")) == 0)

	{

		printf ("Cannot set up UDP!!\n");

		exit(1);

	}

	s = socket(PF_INET, SOCK_DGRAM, ppe->p_proto);

	if (s < 0)

	{

		printf ("Cannot create socket!!: %s\n",strerror(errno));

		exit(1);

	}

	if (connect (s, (struct sockaddr *)&sin, sizeof(sin)) < 0)

	{

		printf ("Cannot connect to host: %s, port: %d\n",host,portno);

		exit(1);

	}

	return (s);

}

int respchecksum()

{

	long temp;

	int i;

	char yn[5];

	if (CVERBOSE) printf("PDU: %d %d %d %d %d %d %s %d\n",

	       ntohs(pdu_in.xjdrsp_type),

	       ntohs(pdu_in.xjdrsp_seq),

	       ntohl(pdu_in.xjdrsp_resindex),

	       ntohl(pdu_in.xjdrsp_dicloc),

	       ntohs(pdu_in.xjdrsp_hitposn),

	       ntohs(pdu_in.xjdrsp_reslen),

	       pdu_in.xjdrsp_resstr,

	       ntohl(pdu_in.xjdrsp_checksum));

	temp = ntohs(pdu_in.xjdrsp_type);

	temp+= ntohs(pdu_in.xjdrsp_seq);

	temp+= ntohl(pdu_in.xjdrsp_resindex);

	temp+= ntohl(pdu_in.xjdrsp_dicloc);

	temp+= ntohs(pdu_in.xjdrsp_hitposn);

	temp+= ntohs(pdu_in.xjdrsp_reslen);

	for (i = 0; i < strlen(pdu_in.xjdrsp_resstr); i++)

		temp+= pdu_in.xjdrsp_resstr[i];

	if (ntohl(pdu_in.xjdrsp_checksum) == temp) 

	{

		chk_cnt = 0;

		return (TRUE);

	}

	if (CVERBOSE) printf("Cal checksum: %d PDU checksum: %d\n",temp,ntohl(pdu_in.xjdrsp_checksum));

	if (chk_cnt++ > 20)

	{

		printf("20 consecutive checksum failures: Try again? ");

		scanf("%s",&yn);

		printf("\n");

		if((yn[0] | 0x20) == 'y') 

		{

			chk_cnt = 0;

			return(FALSE);

		}

		else 

		{

			exit(1);

		}

	}

	return (FALSE);

}

void reqchecksum()

{

	long temp;

	int i;

	temp = ntohs(pdu_out.xjdreq_type);

	temp+= ntohs(pdu_out.xjdreq_seq);

	temp+= ntohs(pdu_out.xjdreq_dicno);

	temp+= ntohl(pdu_out.xjdreq_indexpos);

	temp+= ntohs(pdu_out.xjdreq_schlen);

	for (i = 0; i < strlen(pdu_out.xjdreq_schstr); i++) temp+= pdu_out.xjdreq_schstr[i];

	pdu_out.xjdreq_checksum = htonl(temp);

}

void xjdserver (int type, int dic_no, long index_posn, int sch_str_len,

                unsigned char *sch_str, int *sch_resp, long *res_index, 

                int *hit_posn, int *res_len, unsigned char *res_str,

                long *dic_loc )

{

	int i, ares, sendit;

	gettimeofday((struct timeval *)&timeout,(struct timezone *)&tz);

	timeofday_st = timeout.tv_sec;

	pdu_out.xjdreq_type = htons(type);

	pdu_out.xjdreq_seq = htons(++pduseq);

	pdu_out.xjdreq_dicno = htons(dic_no);

	pdu_out.xjdreq_indexpos = htonl(index_posn);

	pdu_out.xjdreq_schlen = htons(sch_str_len);

	strcpy(pdu_out.xjdreq_schstr,sch_str);

	reqchecksum();

	sendit = TRUE;

	while (TRUE)

	{

		timeout.tv_sec = curr_timer;

		timeout.tv_usec = 0;

		if (sendit) 

		{

			txno++;

			(void) write (s, &pdu_out,sizeof(REQ_PDU));

			if (CVERBOSE) printf("txno %d (seq: %d)\n",txno,pduseq);

		}

		if ((ares = select(nfds, &fildesc, (fd_set *)0, (fd_set *)0, (struct timeval *)&timeout) )< 0)

		{

			printf("Select error: %s\n", strerror(errno));

			exit(1);

		}

		sendit = TRUE; 

		if (ares == 0)

		{

			if (CVERBOSE) printf("Timeout: %d secs (seq: %d)\n",curr_timer,pduseq);

			FD_SET(s, &fildesc);

			if (rep_count < TMAXREP) 

			{

				rep_count++;		

				continue;

			}

			else

			{

				if (curr_timer >= TMAXVAL)

				{

					rep_count = 0;

					printf("Cannot contact Server: %s Try again? ",host);

					scanf("%s",&yn);

					printf("\n");

					if((yn[0] | 0x20) == 'y') 

					{

						curr_timer = TINITVAL;

						continue; 

					}

					else 

					{

						exit(1);

					}

				}

				else

				{

					curr_timer*=2;

					rep_count = 0;

					continue;

				}

			}

		}

		if (CVERBOSE) printf("Something in!\n");

		gettimeofday((struct timeval *)&timeout,(struct timezone *)&tz);

		timeofday_en = timeout.tv_sec;

		elapse = timeofday_en - timeofday_st;

		if (elapse < 1) elapse = 1;

		if (elapse > curr_timer) 

		{

			curr_timer = elapse << 1;

		}

		else

		{

			if (curr_timer - elapse > 2) curr_timer = elapse+2;

		}

		if (recv(s, &pdu_in, sizeof(RSP_PDU), 0) < 0)

		{

			if (errno == 111)

			{

				printf("Cannot contact Server: %s Try again?\n",host);

				scanf("%s",&yn);

				if((yn[0] | 0x20) == 'y') 

				{

					continue; 

				}

				else 

				{

					exit(1);

				}

			}

			printf("UDP recv error: %d %s\n",errno,strerror(errno));

			exit(1);

		}

		if (!respchecksum()) 

		{

			if (CVERBOSE) printf("PDU checksum error (seq: %d)\n",pduseq);

			continue;

		}

		if (ntohs(pdu_in.xjdrsp_seq) != pduseq) 

		{

			if (CVERBOSE) printf("PDU sequence error. Rec: %d Exp: %d\n",ntohs(pdu_in.xjdrsp_seq),pduseq);

			sendit = FALSE;

			continue;

		}

		if (CVERBOSE) printf("Valid PDU: %d %ld %d %d\n",ntohs(pdu_in.xjdrsp_type),

							ntohl(pdu_in.xjdrsp_resindex),

							ntohs(pdu_in.xjdrsp_hitposn),

							ntohs(pdu_in.xjdrsp_reslen));

		*sch_resp = ntohs(pdu_in.xjdrsp_type);

		*res_index = ntohl(pdu_in.xjdrsp_resindex);

		*hit_posn = ntohs(pdu_in.xjdrsp_hitposn);

		*res_len = ntohs(pdu_in.xjdrsp_reslen);

		*dic_loc = ntohl(pdu_in.xjdrsp_dicloc);

		for (i = 0; i < *res_len; i++) 

		{

			res_str[i] = pdu_in.xjdrsp_resstr[i];

			res_str[i+1] = 0;

		}

		return;

	}

}

#include <unistd.h>

/**************************************************************************

*                     X  J  D  F R O N T E N D                            *

*                Common Frontend Routines for client & stand-alone vers.  *

*         Japanese-English Dictionary program (X11 version)               *

*                                                   Author: Jim Breen     *

***************************************************************************/

/*  This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 1, or (at your option)

    any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.     */

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <stdlib.h>

#include <signal.h>

#include <errno.h>

#include "xjdic.h"

/*    Paul Burchard supplied a patch to provide BSD compatibility for xjdic

(it uses the appropriate BSD ioctls in place of the SVR4 stuff).  In

order to enable this, people should compile with the option

-D__STRICT_BSD___ .         */

#ifdef __STRICT_BSD__

#include <sgtty.h>

#else

#ifdef __POSIX__

#include <sys/termios.h>

#else

#include <termio.h>

#endif

#endif

#define WINSIZE_IOCTL_AVAILABLE

static enum

{

IOCTL_ORIG,

IOCTL_RAW

} myi_status = IOCTL_ORIG;

#ifdef __STRICT_BSD__

static struct sgttyb    orig,new;

#else

static struct termio    orig,new;

#endif

extern unsigned char CBname[100];

extern unsigned char Dnamet[10][100],XJDXnamet[10][100];

extern unsigned char *dicbufft[10];

extern unsigned long diclent[10], indkent[10],indptrt[10];

extern int NoDics,CurrDic;

int thisdic = 0;

int gdicnos[10],gdicmax=0,GDmode=FALSE,gdiclen;

int GDALLmode=FALSE;

FILE *fe, *fex, *fclip, *fopen();

#ifdef XJDCLSERV

extern int portno;

extern unsigned char host[];

#endif

#ifdef XJDDIC

extern unsigned long dichits[10],dicmiss[10];

extern unsigned long indhits[10],indmiss[10];

extern unsigned long vbkills;

#endif

char DicDir[100];

int xfilelen;

pid_t pid;

int sig=SIGTSTP;

int ShiftJIS = FALSE,NoSJIS=FALSE;

unsigned char instr[256],radkanj[250][2];

int radnos[250];

unsigned char kanatab[NRKANA*2][7];

int Omode = 0,Smode = 0,Dmode = 0,AKanaMode;

int DRow,DCol,MaxY=MAXLINES,MaxX=MAXCOLS-1,KFlushRes,nok;

unsigned long hittab[NOHITS];

int verblen,DispHit,ksp,hitind,FirstKanj = 0,prieng = FALSE,Extopen=FALSE,NoSkip;

int extlen,extjdxlen;

unsigned char kmodes[2][10] = {"ON","OFF"};

unsigned char kmodes_r[2][10] = {"OFF","ON"};

unsigned long chline,chpos,it;

unsigned char strfilt[10],tempout[80];

unsigned char KSname[50] = {"kanjstroke"};

unsigned char RKname[50] = {"radkfile"};

unsigned char Rname[50] = {"radicals.tm"};

unsigned char ROMname[60] = {"romkana.cnv"};

unsigned char EXTJDXname[80] = {"edictext.xjdx"};

unsigned char EXTname[80] = {"edictext"};

unsigned char Vname[60] = {"vconj"};

unsigned char ENVname[100];

unsigned char cl_rcfile[100];

unsigned char Clip_File[100] = {"clipboard"};

unsigned char GPL_File[100] = {"gnu_licence"};

unsigned char KDNSlist[50];

int jiver = 14;		/*The last time the index structure changed was Version1.4*/

unsigned char sver[] = {SVER};

unsigned char fbuff[512],KLine[KFBUFFSIZE],karray[KANJARRAYSIZE][5];

unsigned char LogLine[200];

unsigned char ksch[50],ktarg[50];

/* The following Help table has "~" to force spaces   */

unsigned char Help[40][81] = {

"\n~~~~~~~~~~~~~~~~~~XJDIC USAGE SUMMARY ",

"At the SEARCH KEY prompt respond with a string of ascii, kana and/or ",

"kanji to look up in the current dictionary (prefix with @ or # to invoke ",

"conversion of romaji to hiragana or katakana)",

"~~~~~~~~~~~~~~~~~~SINGLE CHARACTER COMMANDS",

"~~\\ enter Kanji Dictionary mode~~~? ~~get this Help display",

"~~_ select dictionary files ~~~~~~=/^ cycle up/down dictionary files",

"~~\' set/clear one-off filter~~~~~~; activate/deactivate general filters",

"~~/ toggle kanji_within_compound~~- toggle long kanji display on/off",

"~~$ set global dictionaries ~~~~~~% toggle global search mode on/off",

"~~] display Dictionary Extension ~: toggle verb deinflection on/off",

"~~+ toggle priority English keys~~| toggle unedited display mode on/off",

"~~[ toggle exact_match on/off~~~~~& toggle kana input mode on/off",

"~~{ switch to clipboard input ~~~~} toggle reverse video of matches",

"~~` toggle multiple global disp.~~Ctrl-D  to exit",

"~~! display gnu licence~~~~~~~~~~~Ctrl-Z to suspend",

"~~~~~~Kanji Dictionary mode - prompt is KANJI LOOKUP TYPE:.  Responses:",

"~~a single kanji or a kana reading (default)",

"~~j followed by the 4-digit hexadecimal JIS code for a kanji",

"~~j followed by k and the 4-digit KUTEN code for a kanji",

"~~~~~~~(precede code with `h' for JIS X 0212 kanji.)",

"~~j followed by s and the 4-digit hexadecimal Shift-JIS code for a kanji",

"~~m followed by an (English) kanji meaning",

"~~c followed by an index code such as Nnnn (Nelson), Bnn (Bushu), etc",

"~~r initiates a display of all radicals and their numbers",

"~~l switches the program into the Radical Lookup mode",

"$$$"

};

unsigned char RVon[] = {0x1b,'[','7','m',0};

unsigned char RVoff[] = {0x1b,'[','m',0};

int nofilts=FALSE,filton[NOFILT],filtact[NOFILT],filttype[NOFILT],filtcoden[NOFILT];

unsigned char filtnames[NOFILT][50],filtcodes[NOFILT][10][10];

unsigned char testline[1025],SingleFilter[50];

unsigned char vdicf[VMAX][7],vinfl[VMAX][21],vcomms[41][50];

int strf,Jverb = TRUE,SFFlag=FALSE,vcommno[VMAX];

int ROmode = 1,EMmode = 1,KLmode = 1,KImode = 1,KLRmode,KLcount;

unsigned char vline[250],vstr[13];

unsigned char RadK1[300],RadK2[300],*RKanj1,*RKanj2,*RKSet[10];

unsigned char RKTarg[21];

int rmax,NoSets=0,NoRads,RKStart[300],RKCnt[300];

unsigned char ops[3],kstrokes[7000];

int kstrokelim,kstroketype;

int clipmode=FALSE;

unsigned char clipstring1[51];

unsigned char clipstring2[51]={"XXXX"};

int RVACTIVE = TRUE;

int DicNum;

long DicLoc;

/*====== Prototypes========================================================*/

FILE  *xfopen(char *file_name, char *file_mode, int *xfilelen);

int getcharxx();

void RadDisp();

void RadBuild();

int FindRad(unsigned char char1, unsigned char char2);

void DoLOOKUP();

void RadLoad();

void KSLoad();

void xjdserver (int type, int dic_no, long index_posn, int sch_str_len, 

		unsigned char *sch_str, int *sch_resp, long *res_index, 

		int *hit_posn, int *res_len, unsigned char *res_str,

		long *dic_loc );

void OneShot();

void RadSet();

void Verbtoggle();

void FiltSet();

void xjdicrc();

void DoRADICALS();

int Vlookup();

void AppKanji(unsigned char c1,unsigned char c2);

void Verbinit();

void KOut(unsigned char *sout);

void LoadKana();

void DoRomaji(unsigned char kc);

int kanaconv(int rpos, int rlen);

void togglemode();

void engpritoggle();

void altdic(int dicincr);

void DoKANJI();

void DoJIS();

int addhit(long spot);

void GetEUC(unsigned char *eucline);

void cbreakon();

void cbreakoff();

void ioctlorig();

void ioctlraw();

void Lookup();

void Lookup2();

void DicSet();

void sjis2jis(int *p1,int *p2);/* Ken Lunde's routine  */

void jis2sjis(unsigned char *p1,unsigned char *p2);/* Ken Lunde's routine  */

int stringcomp(unsigned char *s1, unsigned char *s2);

void FixSJIS(unsigned char *jline);

void GetKBStr(unsigned char *prompt);

void ExtFileDisp();

void SeekErr(int iores);

void KOutc(int c);

void KLookup();

int KFlush(unsigned char *msg);

int KEOS (unsigned char *msg);

void NewWinSize();

int kcmp (unsigned char *t1, unsigned char *t2);

unsigned char *DicName(int dn);

/*====== end of prototypes==================================================*/

/* ==== ioctl routines supplied by Cameron Blackwood=======================*/

/* ==== BSD compatibility hacked in by Paul Burchard ==============*/

/*	These routines are to disable/re-enable "cbreak", when I want to

	switch in & out of canonical input processing. Mostly xjdic does

	not use canonical input, as I want to react immediately to most	

	key-presses		*/

void    ioctlraw()

{

  if (myi_status == IOCTL_ORIG)

  {

#ifdef __STRICT_BSD__

    ioctl(0, TIOCGETP, &orig); ioctl(0, TIOCGETP, &new);

    new.sg_flags |= CBREAK; new.sg_flags &= ~ECHO;

    ioctl(0, TIOCSETP, &new);

#else

    ioctl(0, TCGETA, &orig); ioctl(0, TCGETA, &new);

    new.c_lflag &= ~ICANON; new.c_lflag &= ~ISIG; new.c_lflag &= ~ECHO;

    new.c_lflag &= ~IXON;

    new.c_cc[4] = 1; new.c_cc[5] = 0;   ioctl(0, TCSETA, &new);

#endif

    myi_status=IOCTL_RAW;

  }

  else return;

}

void    ioctlorig()

{

#ifdef __STRICT_BSD__

   ioctl(0, TIOCSETP, &orig);

#else

   ioctl(0, TCSETA, &orig);

#endif

    myi_status = IOCTL_ORIG;

}

void cbreakoff()

{

	ioctlorig();

	/*system("stty -cbreak echo");*/

}

void cbreakon()

{

	ioctlraw();

	/*system("stty cbreak -echo");*/

}

int getcharxx()

{

	if (clipmode)

	{

		return('n');

	}

	else

	{

		return(getchar());

	}

}

/*====GetWinSize==== Hank Cohen's routine for getting the (new) window size==*/

/*

 * (The following was supplied by Hank Cohen)

 * We would like to use the Berkeley winsize structure to determine

 * the number of lines and columns in the window.  If that's not

 * available we can use termcap.

 * If using termcap, you will need to compile with "-lcurses -ltermcap".

 */

char termcap_buf[1024];

void GetWinSize()

{

	char *term_name;

#ifdef WINSIZE_IOCTL_AVAILABLE

	struct winsize window;

	signal(SIGWINCH, NewWinSize);

	ioctl(0,TIOCGWINSZ,&window);

	MaxX = window.ws_col;

	MaxX--;

	MaxY = window.ws_row;

#else /* Use termcap */

	if ((term_name = getenv("TERM")) == 0){

		fprintf(stderr,"No TERM in environment!\n");

	} else if (tgetent(termcap_buf, term_name) != 1) {

		fprintf(stderr,"No termcap entry for %s!\n", term_name);

	} else {

		MaxX = tgetnum("co");

		MaxY = tgetnum("li");

	}

#endif  /* termcap */

}

void NewWinSize()

{

	struct winsize window;

	ioctl(0,TIOCGWINSZ,&window);

	MaxX = window.ws_col;

	MaxX--;

	MaxY = window.ws_row;

}

/*=====KSLoad===Load file of kanji/stroke data==========================*/

void KSLoad()

{

	int i,j,k,lno;

	FILE *fk,*fopen();

	fk = xfopen(KSname,"r",&xfilelen);

	lno=0;

	while(!feof(fk))

	{

		fgets(testline,9,fk);

		if(feof(fk)) break;

		testline[3] = 0;

		lno++;

		i = ((testline[0] & 0x7f)-0x30)*94 + ((testline[1] & 0x7f) - 0x21);

		if ((i < 0) || (i > 6999))

		{

			printf("Bad kanji in %s at line %d (%s)\n",KSname,lno,testline);

			i = 6999;

		}

		kstrokes[i] = testline[2]-'0';

	}

	fclose(fk);

}

/*=====RadLoad===Load file of Radical Data==============================*/

void RadLoad()

{

	int i,j,k;

	FILE *fk,*fopen();

	fk = xfopen(RKname,"r", &xfilelen);

	k = xfilelen/2;

	RKanj1 = malloc(k*sizeof(char));

	if (RKanj1==NULL)

	{

		printf("malloc failed for radical tables!\n");

		exit(1);

	}

	RKanj2 = malloc(k*sizeof(char));

	if (RKanj2==NULL)

	{

		printf("malloc failed for radical tables!\n");

		exit(1);

	}

	i = -1;

	j = 0;

	rmax = 0;

	while(!feof(fk))

	{

		fgets(testline,199,fk);

		if(feof(fk)) break;

		if (testline[0] == '$')

		{

			i++;

			RadK1[i] = testline[2];

			RadK2[i] = testline[3];

			RKStart[i] = j;

			RKCnt[i] = 0;

			if (i != 0)

			{

				if (RKCnt[i-1] > rmax) rmax = RKCnt[i-1];

			}

		}

		else

		{

			for (k = 0; k < strlen(testline); k++)

			{

				if (testline[k] < 127) continue;

				RKanj1[j] = testline[k];

				RKanj2[j] = testline[k+1];

				RKCnt[i]++;

				j++;

				k++;

			}

		}

	}

	fclose(fk);

	NoRads = i;

	for (i=0; i<10;i++)

	{

		RKSet[i] = malloc(2*rmax+1);

		if (RKSet[i] == NULL)

		{

			printf("malloc() failed for Radical set(s)!\n");

		}

	}

}

/*=====DoRomaji==collect search key from keyboard. Convert to kana.======*/

/*	Code originally from JDIC			*/

void DoRomaji(unsigned char kc)

{

	int is;

	unsigned char c;

/* collect the search string   */

  Smode = 1;

  if(kc == '#') Smode = 2;

  is = 0;

  ksp = 0;

  c = 0;

  ktarg[0] = 0;

  printf("\r                                         \r%sROMAJI ENTRY:%s ",RVon,RVoff);

  while (c != 0x0a)	  /* loop until Enter is pressed   */

  {

	c = getcharxx();

	if ((c == 0x8)||(c == 0x7f))  /* backspace  */

	{

			if (is != ksp)  /* kana mode - back over a romaji  */

			{

				ksch[is-1] = '\0';

				is--;

  				sprintf(tempout,"\r                                     \r%sROMAJI ENTRY:%s %s%s",RVon,RVoff,ktarg,ksch+ksp);

				KOut(tempout);

				continue;

			}

			else

			{

				if (strlen(ktarg) != 0)  /* kana mode - back over a kana  */

				{

					ktarg[strlen(ktarg)-2] = '\0';

  					sprintf(tempout,"\r                                     \r%sROMAJI ENTRY:%s %s%s",RVon,RVoff,ktarg,ksch+ksp);

					KOut(tempout);

					continue;

				}

			}

	}

	if (c > 32)   /* ordinary character - store and display   */

	{

		ksch[is] = c | 0x20;

		ksch[is+1] = '\0';

		is++;

  		sprintf(tempout,"\r                                     \r%sROMAJI ENTRY:%s %s%s",RVon,RVoff,ktarg,ksch+ksp);

		KOut(tempout);

  	}

	if (ksp != is)

	{

/* the input string so far is now parsed for romaji -> kana conversions.

   function "kanaconv" is used for the various sub-strings    */

/* if there is an "nn", "nm" or "mm", convert to first to "q" to force it to be

   converted to a kana "n"   */

		if ((ksch[ksp] == 'n')&&(ksch[ksp+1] == 'n')) ksch[ksp] = 'q';

		if ((ksch[ksp] == 'm')&&(ksch[ksp+1] == 'm')) ksch[ksp] = 'q';

		if ((ksch[ksp] == 'n')&&(ksch[ksp+1] == 'm')) ksch[ksp] = 'q';

/* if there is "nx", where "x" is not a vowel or a "y", force the "n".  */

		if (((ksch[ksp] == 'n')||(ksch[ksp] == 'm'))&&(ksch[ksp+1] != 0))

		{

			c = ksch[ksp+1];

			if((c!='y')&&(c!='a')&&(c!='e')&&(c!='i')&&(c!='o')&&(c!='u')&&(c!='\''))

			{

				ksch[ksp] = 'q';

			}

		}

		if(kanaconv(ksp,1))  /*  match on a,e,i,o,u,q or -  ?  */

		{

			continue;

		}

		if(ksch[ksp] == '\'')

		{

			ksp++;

			continue;

		}

		if (ksch[ksp] == ksch[ksp+1])  /* double consonant - force small

						 "tsu" */

		{

			ksch[ksp] = '*';

			kanaconv(ksp,1);

			continue;

		}

		if(kanaconv(ksp,2))  /* match on two letter syllable   */

		{

			continue;

		}

		if(kanaconv(ksp,3))  /*match on 3 letter syllable    */

		{

			continue;

		}

		if(kanaconv(ksp,4))  /*match on 4 letter syllable    */

		{

			continue;

		}

	}		/* end of rom->kana */

  }			/* end of while loop */

  if (ksch[ksp] =='n')  /*flush out a trailing "n"*/

  {

	ksch[ksp] = 'q';

	kanaconv(ksp,1);

  }

  strcpy(instr,ktarg);

}

/*========kanaconv==convert romaji to kana==============================*/

/*	More code from JDIC			*/

int kanaconv(int rpos, int rlen)

{

/* rpos and rlen are the start and length of the romaji characters in

   array ksch.  Smode specifies hira or kata. If found, the kana is

   appended to ktarg and TRUE returned.                          */

	int koff,ki;

	unsigned char targ[50];

	koff = (Smode-1)*NRKANA;

	for(ki = 0; ki < rlen; ki++)

	{

		targ[ki] = ksch[rpos+ki];

	}

	targ[rlen] = 0;

	for (ki = koff; ki < koff+NRKANA; ki+=2)

	{

		if (strlen(targ) != strlen(kanatab[ki])) continue;

		if (stringcomp(targ,kanatab[ki]) != 0) continue;

		strcat(ktarg,kanatab[ki+1]);

		ksp = ksp+rlen;

  		sprintf(tempout,"\r                                     \r%sROMAJI ENTRY:%s %s%s",RVon,RVoff,ktarg,ksch+ksp);

		KOut(tempout);

		return (TRUE);

	}

	return(FALSE);

}

/* ==== LoadKana=== Load the romaji to kana conversion file============*/

void LoadKana()

{

	int i,ih,mode;

	FILE *fp,*fopen();

	unsigned char LKin[80],*ptr;

	for (i = 0; i < NRKANA*2; i++) strcpy(kanatab[i]," ");

	fp = xfopen(ROMname,"r", &xfilelen);

	mode = 0;

	while (!feof(fp))

	{

		fgets(LKin,79,fp);

		if (feof(fp))break;

		/*LKin[strlen(LKin)-1] = '\0';*/

		if(LKin[0] == '#')continue;

		if((LKin[0] == '$')&&((LKin[1]|0x20) == 'h'))

		{

			mode = 0;

			ih = 0;

			continue;

		}

		if((LKin[0] == '$')&&((LKin[1]|0x20) == 'k'))

		{

			mode = 1;

			ih = 0;

			continue;

		}

		ptr = (unsigned char *)strtok(LKin," \t");

		if ( ptr != NULL ) strcpy(kanatab[mode*NRKANA+ih*2+1],ptr);

		ptr = (unsigned char *)strtok(NULL," \t\r\n");

		if ( ptr != NULL ) strcpy(kanatab[mode*NRKANA+ih*2],ptr);

		ih++;

		if(ih == NRKANA) 

		{

			printf("Too many romaji table entries!");

			exit(1);

		}

	}

	fclose(fp);

}

/*======jis2sjis  (from Ken Lunde) =====================================*/

void jis2sjis(unsigned char *p1,unsigned char *p2) /* courtesy of Ken Lunde */

{

    register unsigned char c1 = *p1;

    register unsigned char c2 = *p2;

    register int rowOffset = c1 < 95 ? 112 : 176;

    register int cellOffset = c1 % 2 ? 31 + (c2 > 95) : 126;

    *p1 = ((c1 + 1) >> 1) + rowOffset;

    *p2 = c2 + cellOffset;

}

/*====KEOS===End of screen processing for KFlush==================*/

int KEOS (unsigned char *msg)

{

	unsigned char ck;

	if (DRow < MaxY-2) return(TRUE);

	DRow = 0;

	if (strlen(msg) == 0) return (TRUE);

	printf("%s\n",msg);

	ck = getcharxx();

	if ((ck == 'n')||(ck == 'N')) return (FALSE);

	if ((ck == 'y')||(ck == 'Y')) return (TRUE);

	if ((ck != 0xa) && (ck != 0xd)) ungetc(ck,stdin);

	return (FALSE);

}

/*====KFlush==== Output a line, folding if necessary===============*/

/*	This is now the main screen output routine. An array "KLine"

	is built up of text to be output. KFlush() sends it to the screen,

	folding the line at white-space if it is about to hit the RHS.

	It also tests for end of screen, and prompts for continuation,

	using the KEOS(). Returns TRUE for continue, and FALSE for 

	stopping.  

	Called with the prompt measseage.			*/

int KFlush(unsigned char *msg)

{

	unsigned char *kptr,ktemp[512];

	int retf,it,j;

	int Test;

	if (strlen(KLine) == 0) return (TRUE);

	kptr = (unsigned char *)strtok(KLine," ");

	while (kptr != NULL)

	{

		Test = MaxX;

		strcpy(ktemp,kptr);

		if (ktemp[0] == '\t')

		{

			it = DCol % 10;

			if (it != 0) 

			{

				DCol = DCol+10-it;

				if (DCol <= Test-1)

				{

					for (j = 0;j < 10-it;j++) KOut(" ");

				}

			}

			strcpy(ktemp,ktemp+1);

		}

		it = strlen(ktemp);

		if (DCol+it < Test)

		{

			DCol = DCol+it+1;

		}

		else

		{

			KOut("\n");

			DRow++;

			DCol=it+1;

			retf = KEOS(msg);

			if (!retf) return (FALSE);

		}

		KOut(ktemp);

		if (DCol <= MAXCOLS) KOut(" ");

		kptr = (unsigned char *)strtok(NULL," ");

	}

	KOut("\n");

	DRow++;

	retf = KEOS(msg);

	DCol = 0;

	if (!retf) return (FALSE);

	return (TRUE);

}

/*====KOutc===add a character to KLine=============================*/

void KOutc(int c)

{

	unsigned char tmp[2];

	tmp[0] = c;

	tmp[1] = 0;

	strcat(KLine,tmp);

	return;

}

/*=====KOut===output kana/kanji according to selected mode===========*/

/*	Mostly called from KFlush. Outputs the parameter string, in the

	specified JIS mode.					*/

void KOut(unsigned char *sout)

{

	int i;

	unsigned char c1,c2;

	for (i = 0; i < strlen(sout); i++)

	{

		c1 = sout[i]; c2 = sout[i+1];

		if (c1 < 127)

		{

			if (c1 == '~') c1 = ' ';

			printf("%c",c1);

			continue;

		}

		switch(Omode)

		{

		case 0 :  /* JIS (default)  */

			if (c1 == 0x8f)

			{

				printf("%c$(D%c%c%c(B",0x1b,c2&0x7f,sout[i+2]&0x7f,0x1b);

				i+=2;

				break;

			}

			printf("%c$B%c%c%c(B",0x1b,c1&0x7f,c2&0x7f,0x1b);

			i++;

			break;

		case 1 : /* EUC (internal format) */

			if (c1 == 0x8f)

			{

				printf("%c%c%c",c1,c2,sout[i+2]);

				i+=2;

				break;

			}

			printf("%c%c",c1,c2);

			i++;

			break;

		case 2 : /* Shift-JIS */

			c1 -= 128; c2 -= 128;

			jis2sjis(&c1,&c2);

			printf("%c%c",c1,c2);

			i++;

			break;

		}

	}

}

/*======function to test if this entry has already been displayed=====*/

int addhit(long spot)

{

	int i;

	if (spot == 0) return(TRUE);

	for (i=0;i<=hitind;i++)

	{

		if(hittab[i] == spot) return(FALSE);

	}

	if(hitind < NOHITS) hitind++;

	hittab[hitind] = spot;

	return(TRUE);

}

/*====GetEUC - ensures that any JIS in the string is EUC ============*/

/*      Based on the GetEUC in JREADER, this routine examines

	the string "instr" and converts any JIS or SJIS to EUC.

	The result is placed in the specified string.        */

void GetEUC(unsigned char *eucline)

{

	int i,j,SI,J212,J212sw;

	J212 = FALSE;

	eucline[0] = '\0';

	chline = 0;

	chpos = 0;

	SI = FALSE;

	ShiftJIS = FALSE;

	j = 0;

	for (i = 0; i < strlen(instr); i++)

	{

		if((instr[i]==0x1b)&&(instr[i+1]=='$')&&(instr[i+2]=='(')&&(instr[i+3]=='D'))

		{

			SI = TRUE;

			J212 = TRUE;

			J212sw = 0;

			NoSJIS = TRUE;

			i+=3;

			continue;

		}

		if((instr[i]==0x1b)&&(instr[i+1]=='$')&&(instr[i+2]=='B'))

		{

			SI = TRUE;

			J212 = FALSE;

			i+=2;

			continue;

		}

		if((instr[i]==0x1b)&&(instr[i+1]=='$')&&(instr[i+2]=='@'))

		{

			SI = TRUE;

			J212 = FALSE;

			i+=2;

			continue;

		}

		if((instr[i]==0x1b)&&(instr[i+1]=='(')&&(instr[i+2]=='J'))

		{

			SI = FALSE;

			J212 = FALSE;

			i+=2;

			continue;

		}

		if((instr[i]==0x1b)&&(instr[i+1]=='(')&&(instr[i+2]=='B'))

		{

			SI = FALSE;

			J212 = FALSE;

			i+=2;

			continue;

		}

		if (instr[i] == '\0')break;

		if (SI)

		{

			if (J212 && (J212sw == 0)) eucline[j++] = 0x8f;

			eucline[j] = instr[i] | 0x80;

			J212sw = (J212sw+1) % 2;

		}

		else

		{

			eucline[j] = instr[i];

		}

		j++;

		eucline[j] = '\0';

	}

/*  fix up SHIFT-JIS, if present  */

	if (!NoSJIS) FixSJIS(eucline);

}

/*====FixSJIS=== convert any SJIS to EUC in a string==================*/

void FixSJIS(unsigned char *jline)

{

	int i,p1,p2,ShiftJIS;

	ShiftJIS = FALSE;

	for (i = 0; i < strlen(jline); i++)

	{

		p1 = jline[i];

		if (p1 < 127)continue;

		p2 = jline[i+1];

        	if ((p1 >= 129) && (p1 <= 159)) ShiftJIS = TRUE;

		if (((p1 >= 224) && (p1 <= 239))&& ((p2 >= 64) && (p2 <= 158))) ShiftJIS = TRUE;

		if (ShiftJIS)

		{

            		sjis2jis   (&p1,&p2);

            		p1 += 128;

            		p2 += 128;

			jline[i] = p1;

			jline[i+1] = p2;

		}

		i++;

	}

}

/*===sjis2jis    - convert ShiftJIS to JIS ===========================*/

void sjis2jis   (int *p1,int *p2)   /* Ken Lunde's routine  */

{

    register unsigned char c1 = *p1;

    register unsigned char c2 = *p2;

    register int adjust = c2 < 159;

    register int rowOffset = c1 < 160 ? 112 : 176;

    register int cellOffset = adjust ? (31 + (c2 > 127)) : 126;

    *p1 = ((c1 - rowOffset) << 1) - adjust;

    *p2 -= cellOffset;

}

/*====ExtFileDisp===Display from EDICTEXT file=======================*/

void ExtFileDisp()

{

	unsigned extrec[2],seekoff,iores,hi,lo,mid,ejdxtest[2];

	unsigned char Ssch[20];

	int bsres,i;

    printf("%sExtension Key:%s ",RVon,RVoff);

	GetKBStr("Extension Key:");

	if(fbuff[0] < 128) 

	{

		printf("\nThe extension file has Kanji & Kana keys\n");

		return;

	}

	if(!Extopen)

	{

		fe = xfopen(EXTname,"rb", &extlen);

        	fex  = xfopen(EXTJDXname,"rb", &extjdxlen);

		Extopen = TRUE;

		extlen++;

		fread(ejdxtest,sizeof(long),1,fex);

		if (ejdxtest[0] != (extlen+jiver))

		{

			printf("\nEDICT Extension file & Index Mismatch! %ld %ld\n",ejdxtest[0],extlen+jiver);

			exit(1);

		}

	}

	lo = 0;

	hi = (extjdxlen/(2*sizeof(long)))-1;

	while(TRUE)

	{

		mid = (lo+hi)/2;

		seekoff = mid;

		seekoff *= (2*sizeof(long));

		seekoff+=sizeof(long);

		if((iores = fseek(fex,seekoff,SEEK_SET)) != 0)SeekErr(iores);

		iores = fread(&extrec,sizeof(long),2,fex);

		seekoff = extrec[0];

		if((iores = fseek(fe,seekoff,SEEK_SET)) != 0)SeekErr(iores);

		iores = fread(&Ssch,sizeof(char),19,fe);

		Ssch[19] = 0;

		i = 0;

		bsres = 0;

		for (i = 0; Ssch[i] != 0 ;i++)

		{

			if (Ssch[i] < 128) break;

			if (fbuff[i] < 128) break;

			if (fbuff[i] < Ssch[i])

			{

				bsres = -1;

				break;

			}

			if (fbuff[i] > Ssch[i])

			{

				bsres = 1;

				break;

			}

		}

		if ((bsres != 0) && ((lo + hi) == 0)) break;

		if(bsres < 0)

		{

			if (mid == 0) break;

			hi = mid-1;

		}

		else

		{

			lo = mid+1;

		}

		if (bsres  == 0) break;

		if (lo > hi) break;

		if (hi < 0) break;

	}

	if (bsres == 0)

	{

		printf("\n%sDictionary Extension Display%s\n",RVon,RVoff);

		seekoff = extrec[1];

		if((iores = fseek(fe,seekoff,SEEK_SET)) != 0)SeekErr(iores);

		strcpy (KLine," <");

		DRow = 0;

		DCol = 0;

		while(!feof(fe))

		{

			fgets(LogLine,199,fe);

			if (feof(fe)) break;

			if ((LogLine[0] == '<') && (LogLine[1] > 128)) break;

			for (i = strlen(LogLine); i >= 0; i--)

			{

				if (LogLine[i] < 0x20) LogLine[i] = 0;

			}

			strcat(KLine,LogLine);

			if (!KFlush("Continue displaying extension information? (y/n)")) break;

			DCol = 0;

			strcpy (KLine," ");

		}

		return;

	}

	if (bsres != 0)

	{

		printf("\nNot found in Extension file!\n");

		return;

	}