Fix bugs

CMakeLists.txt

@@ -14,6 +14,9 @@ add_library(sj4core STATIC ${SJ4CORE_SRCS})
 target_include_directories(sj4core PUBLIC include/sj4common include/sj4core)
 target_include_directories(sj4core PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 target_link_libraries(sj4core PUBLIC sj4common)
+if(SJ4_GLOBAL)
+	target_compile_definitions(sj4core PUBLIC SJ4_GLOBAL)
+endif()
 
 file(GLOB_RECURSE SJ4RKCV_SRCS lib/sj4rkcv/**.c)
 add_library(sj4rkcv STATIC ${SJ4RKCV_SRCS})
@@ -24,13 +27,11 @@ target_link_libraries(sj4rkcv PUBLIC sj4common)
 file(GLOB_RECURSE SJ4MKDIC_SRCS src/sj4mkdic/**.c)
 add_executable(sj4mkdic ${SJ4MKDIC_SRCS})
 target_include_directories(sj4mkdic PRIVATE include/sj4common include/sj4core)
+target_compile_definitions(sj4mkdic PRIVATE UTF8 ENGLISH)
+target_link_libraries(sj4mkdic PUBLIC sj4common)
 
+if(NOT SJ4_GLOBAL)
 	file(GLOB_RECURSE SJ4TEST_SRCS src/sj4test/**.c)
 	add_executable(sj4test ${SJ4TEST_SRCS})
 	target_link_libraries(sj4test PRIVATE sj4core)
-
-if(SJ4_GLOBAL)
-	target_compile_definitions(sj4core PUBLIC SJ4_GLOBAL)
 endif()
-
-target_compile_definitions(sj4mkdic PRIVATE UTF8 ENGLISH)

include/sj4common/sj4compat.h

@@ -0,0 +1,11 @@
+#ifndef __SJ4COMPAT_H__
+#define __SJ4COMPAT_H__
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+int    sj4_snprintf(char*, size_t, const char*, ...);
+size_t sj4_strlcpy(char*, const char*, size_t);
+
+#endif

include/sj4common/sj_string.h

@@ -18,8 +18,8 @@
 #define SJ_STRING_H
 
 /* string.c */
-int sj4_str_sjistoeuc(unsigned char*, int, unsigned char*, unsigned char*, int*);
+int sj4_str_sjistoeuc(unsigned char*, int, unsigned char*, int, unsigned char*, int*);
-int sj4_str_euctosjis(unsigned char*, int, unsigned char*, unsigned char*, int*);
+int sj4_str_euctosjis(unsigned char*, int, unsigned char*, int, unsigned char*, int*);
 int sj4_sjistoeuclen(unsigned char*, int);
 
 int	       sj4_sjistoeuc(unsigned char* s, int, unsigned char*, int);

include/sj4core/sj_compat.h

@@ -1,31 +0,0 @@
-#ifndef __SJ4_COMPAT_H__
-#define __SJ4_COMPAT_H__
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-#if defined(_MSC_VER)
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-static int __inline sj4_snprintf(char* buffer, size_t count, const char* fmt, ...) {
-	int	st;
-	va_list va;
-
-	va_start(va, fmt);
-	st = vsprintf(buffer, fmt, va);
-	va_end(va);
-
-	return st;
-}
-#else
-#define sj4_snprintf snprintf
-#endif
-
-#define sj4_strlcpy(x, y, z) strcpy((x), (y))
-#else
-#define sj4_snprintf snprintf
-#define sj4_strlcpy strlcpy
-#endif
-
-#endif

include/sj4core/sj_kanakan.h

@@ -76,7 +76,7 @@ int codesize(u_char);
 extern u_char chrtbl[256];
 
 /* cl2knj.c */
-int cl2knj(SJ4_CONTEXT u_char*, int, u_char*);
+int cl2knj(SJ4_CONTEXT u_char*, int, u_char*, int);
 int nextcl(SJ4_CONTEXT u_char*, int);
 int prevcl(SJ4_CONTEXT u_char*, int);
 int selectnum(SJ4_CONTEXT2);

include/sj4core/sj_rename.h

@@ -432,6 +432,6 @@
 
 #define termtbl Jtermtbl
 
-#include <sj_compat.h>
+#include <sj4compat.h>
 
 #endif

include/sj4core/sj_typedef.h

@@ -49,16 +49,11 @@ typedef void (*VFunc)(
     void*,
 #endif
     void*, void*, void*);
-typedef u_char* (*UCPFunc)(
-#ifndef SJ4_GLOBAL
-    void*,
-#endif
-    u_char*, u_char*, int);
 typedef int (*IFunc)(
 #ifndef SJ4_GLOBAL
     void*,
 #endif
-    void*, int);
+    void*, short);
 
 typedef int (*IFuncDict)(
 #ifndef SJ4_GLOBAL

lib/sj4common/bsd-snprintf.c

@@ -0,0 +1,773 @@
+/*
+ * Copyright Patrick Powell 1995
+ * This code is based on code written by Patrick Powell (papowell@astart.com)
+ * It may be used for any purpose as long as this notice remains intact
+ * on all source code distributions
+ */
+
+/**************************************************************
+ * Original:
+ * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh.  This sort of thing is always nasty do deal with.  Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length.  This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ *
+ * More Recently:
+ *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
+ *  This was ugly.  It is still ugly.  I opted out of floating point
+ *  numbers, but the formatter understands just about everything
+ *  from the normal C string format, at least as far as I can tell from
+ *  the Solaris 2.5 printf(3S) man page.
+ *
+ *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
+ *    Ok, added some minimal floating point support, which means this
+ *    probably requires libm on most operating systems.  Don't yet
+ *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
+ *    was pretty badly broken, it just wasn't being exercised in ways
+ *    which showed it, so that's been fixed.  Also, formated the code
+ *    to mutt conventions, and removed dead code left over from the
+ *    original.  Also, there is now a builtin-test, just compile with:
+ *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
+ *    and run snprintf for results.
+ *
+ *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
+ *    The PGP code was using unsigned hexadecimal formats.
+ *    Unfortunately, unsigned formats simply didn't work.
+ *
+ *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
+ *    The original code assumed that both snprintf() and vsnprintf() were
+ *    missing.  Some systems only have snprintf() but not vsnprintf(), so
+ *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
+ *
+ *  Andrew Tridgell (tridge@samba.org) Oct 1998
+ *    fixed handling of %.0f
+ *    added test for HAVE_LONG_DOUBLE
+ *
+ * tridge@samba.org, idra@samba.org, April 2001
+ *    got rid of fcvt code (twas buggy and made testing harder)
+ *    added C99 semantics
+ *
+ * date: 2002/12/19 19:56:31;  author: herb;  state: Exp;  lines: +2 -0
+ * actually print args for %g and %e
+ *
+ * date: 2002/06/03 13:37:52;  author: jmcd;  state: Exp;  lines: +8 -0
+ * Since includes.h isn't included here, VA_COPY has to be defined here.  I don't
+ * see any include file that is guaranteed to be here, so I'm defining it
+ * locally.  Fixes AIX and Solaris builds.
+ *
+ * date: 2002/06/03 03:07:24;  author: tridge;  state: Exp;  lines: +5 -13
+ * put the ifdef for HAVE_VA_COPY in one place rather than in lots of
+ * functions
+ *
+ * date: 2002/05/17 14:51:22;  author: jmcd;  state: Exp;  lines: +21 -4
+ * Fix usage of va_list passed as an arg.  Use __va_copy before using it
+ * when it exists.
+ *
+ * date: 2002/04/16 22:38:04;  author: idra;  state: Exp;  lines: +20 -14
+ * Fix incorrect zpadlen handling in fmtfp.
+ * Thanks to Ollie Oldham <ollie.oldham@metro-optix.com> for spotting it.
+ * few mods to make it easier to compile the tests.
+ * addedd the "Ollie" test to the floating point ones.
+ *
+ * Martin Pool (mbp@samba.org) April 2003
+ *    Remove NO_CONFIG_H so that the test case can be built within a source
+ *    tree with less trouble.
+ *    Remove unnecessary SAFE_FREE() definition.
+ *
+ * Martin Pool (mbp@samba.org) May 2003
+ *    Put in a prototype for dummy_snprintf() to quiet compiler warnings.
+ *
+ *    Move #endif to make sure VA_COPY, LDOUBLE, etc are defined even
+ *    if the C library has some snprintf functions already.
+ **************************************************************/
+
+#include "sj4compat.h"
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef va_copy
+#define VA_COPY(dest, src) va_copy(dest, src)
+#else
+#define VA_COPY(dest, src) (dest) = (src)
+#endif
+
+#ifdef HAVE_LONG_DOUBLE
+#define LDOUBLE long double
+#else
+#define LDOUBLE double
+#endif
+
+#ifdef HAVE_LONG_LONG
+#define LLONG long long
+#else
+#define LLONG long
+#endif
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+/* format read states */
+#define DP_S_DEFAULT 0
+#define DP_S_FLAGS 1
+#define DP_S_MIN 2
+#define DP_S_DOT 3
+#define DP_S_MAX 4
+#define DP_S_MOD 5
+#define DP_S_CONV 6
+#define DP_S_DONE 7
+
+/* format flags - Bits */
+#define DP_F_MINUS (1 << 0)
+#define DP_F_PLUS (1 << 1)
+#define DP_F_SPACE (1 << 2)
+#define DP_F_NUM (1 << 3)
+#define DP_F_ZERO (1 << 4)
+#define DP_F_UP (1 << 5)
+#define DP_F_UNSIGNED (1 << 6)
+
+/* Conversion Flags */
+#define DP_C_SHORT 1
+#define DP_C_LONG 2
+#define DP_C_LDOUBLE 3
+#define DP_C_LLONG 4
+
+#define char_to_int(p) ((p) - '0')
+#ifndef MAX
+#define MAX(p, q) (((p) >= (q)) ? (p) : (q))
+#endif
+
+static size_t dopr(char* buffer, size_t maxlen, const char* format,
+		   va_list args_in);
+static void   fmtstr(char* buffer, size_t* currlen, size_t maxlen,
+		     char* value, int flags, int min, int max);
+static void   fmtint(char* buffer, size_t* currlen, size_t maxlen,
+		     LLONG value, int base, int min, int max, int flags);
+static void   fmtfp(char* buffer, size_t* currlen, size_t maxlen,
+		    LDOUBLE fvalue, int min, int max, int flags);
+static void   dopr_outch(char* buffer, size_t* currlen, size_t maxlen, char c);
+
+static size_t dopr(char* buffer, size_t maxlen, const char* format, va_list args_in) {
+	char	ch;
+	LLONG	value;
+	LDOUBLE fvalue;
+	char*	strvalue;
+	int	min;
+	int	max;
+	int	state;
+	int	flags;
+	int	cflags;
+	size_t	currlen;
+	va_list args;
+
+	VA_COPY(args, args_in);
+
+	state	= DP_S_DEFAULT;
+	currlen = flags = cflags = min = 0;
+	max			       = -1;
+	ch			       = *format++;
+
+	while(state != DP_S_DONE) {
+		if(ch == '\0')
+			state = DP_S_DONE;
+
+		switch(state) {
+		case DP_S_DEFAULT:
+			if(ch == '%')
+				state = DP_S_FLAGS;
+			else
+				dopr_outch(buffer, &currlen, maxlen, ch);
+			ch = *format++;
+			break;
+		case DP_S_FLAGS:
+			switch(ch) {
+			case '-':
+				flags |= DP_F_MINUS;
+				ch = *format++;
+				break;
+			case '+':
+				flags |= DP_F_PLUS;
+				ch = *format++;
+				break;
+			case ' ':
+				flags |= DP_F_SPACE;
+				ch = *format++;
+				break;
+			case '#':
+				flags |= DP_F_NUM;
+				ch = *format++;
+				break;
+			case '0':
+				flags |= DP_F_ZERO;
+				ch = *format++;
+				break;
+			default:
+				state = DP_S_MIN;
+				break;
+			}
+			break;
+		case DP_S_MIN:
+			if(isdigit((unsigned char)ch)) {
+				min = 10 * min + char_to_int(ch);
+				ch  = *format++;
+			} else if(ch == '*') {
+				min   = va_arg(args, int);
+				ch    = *format++;
+				state = DP_S_DOT;
+			} else {
+				state = DP_S_DOT;
+			}
+			break;
+		case DP_S_DOT:
+			if(ch == '.') {
+				state = DP_S_MAX;
+				ch    = *format++;
+			} else {
+				state = DP_S_MOD;
+			}
+			break;
+		case DP_S_MAX:
+			if(isdigit((unsigned char)ch)) {
+				if(max < 0)
+					max = 0;
+				max = 10 * max + char_to_int(ch);
+				ch  = *format++;
+			} else if(ch == '*') {
+				max   = va_arg(args, int);
+				ch    = *format++;
+				state = DP_S_MOD;
+			} else {
+				state = DP_S_MOD;
+			}
+			break;
+		case DP_S_MOD:
+			switch(ch) {
+			case 'h':
+				cflags = DP_C_SHORT;
+				ch     = *format++;
+				break;
+			case 'l':
+				cflags = DP_C_LONG;
+				ch     = *format++;
+				if(ch == 'l') { /* It's a long long */
+					cflags = DP_C_LLONG;
+					ch     = *format++;
+				}
+				break;
+			case 'L':
+				cflags = DP_C_LDOUBLE;
+				ch     = *format++;
+				break;
+			default:
+				break;
+			}
+			state = DP_S_CONV;
+			break;
+		case DP_S_CONV:
+			switch(ch) {
+			case 'd':
+			case 'i':
+				if(cflags == DP_C_SHORT)
+					value = va_arg(args, int);
+				else if(cflags == DP_C_LONG)
+					value = va_arg(args, long int);
+				else if(cflags == DP_C_LLONG)
+					value = va_arg(args, LLONG);
+				else
+					value = va_arg(args, int);
+				fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
+				break;
+			case 'o':
+				flags |= DP_F_UNSIGNED;
+				if(cflags == DP_C_SHORT)
+					value = va_arg(args, unsigned int);
+				else if(cflags == DP_C_LONG)
+					value = (long)va_arg(args, unsigned long int);
+				else if(cflags == DP_C_LLONG)
+					value = (long)va_arg(args, unsigned LLONG);
+				else
+					value = (long)va_arg(args, unsigned int);
+				fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
+				break;
+			case 'u':
+				flags |= DP_F_UNSIGNED;
+				if(cflags == DP_C_SHORT)
+					value = va_arg(args, unsigned int);
+				else if(cflags == DP_C_LONG)
+					value = (long)va_arg(args, unsigned long int);
+				else if(cflags == DP_C_LLONG)
+					value = (LLONG)va_arg(args, unsigned LLONG);
+				else
+					value = (long)va_arg(args, unsigned int);
+				fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
+				break;
+			case 'X':
+				flags |= DP_F_UP;
+			case 'x':
+				flags |= DP_F_UNSIGNED;
+				if(cflags == DP_C_SHORT)
+					value = va_arg(args, unsigned int);
+				else if(cflags == DP_C_LONG)
+					value = (long)va_arg(args, unsigned long int);
+				else if(cflags == DP_C_LLONG)
+					value = (LLONG)va_arg(args, unsigned LLONG);
+				else
+					value = (long)va_arg(args, unsigned int);
+				fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
+				break;
+			case 'f':
+				if(cflags == DP_C_LDOUBLE)
+					fvalue = va_arg(args, LDOUBLE);
+				else
+					fvalue = va_arg(args, double);
+				/* um, floating point? */
+				fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
+				break;
+			case 'E':
+				flags |= DP_F_UP;
+			case 'e':
+				if(cflags == DP_C_LDOUBLE)
+					fvalue = va_arg(args, LDOUBLE);
+				else
+					fvalue = va_arg(args, double);
+				fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
+				break;
+			case 'G':
+				flags |= DP_F_UP;
+			case 'g':
+				if(cflags == DP_C_LDOUBLE)
+					fvalue = va_arg(args, LDOUBLE);
+				else
+					fvalue = va_arg(args, double);
+				fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
+				break;
+			case 'c':
+				dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
+				break;
+			case 's':
+				strvalue = va_arg(args, char*);
+				if(!strvalue) strvalue = "(NULL)";
+				if(max == -1) {
+					max = strlen(strvalue);
+				}
+				if(min > 0 && max >= 0 && min > max) max = min;
+				fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
+				break;
+			case 'p':
+				strvalue = va_arg(args, void*);
+				fmtint(buffer, &currlen, maxlen, (long)strvalue, 16, min, max, flags);
+				break;
+			case 'n':
+				if(cflags == DP_C_SHORT) {
+					short int* num;
+					num  = va_arg(args, short int*);
+					*num = currlen;
+				} else if(cflags == DP_C_LONG) {
+					long int* num;
+					num  = va_arg(args, long int*);
+					*num = (long int)currlen;
+				} else if(cflags == DP_C_LLONG) {
+					LLONG* num;
+					num  = va_arg(args, LLONG*);
+					*num = (LLONG)currlen;
+				} else {
+					int* num;
+					num  = va_arg(args, int*);
+					*num = currlen;
+				}
+				break;
+			case '%':
+				dopr_outch(buffer, &currlen, maxlen, ch);
+				break;
+			case 'w':
+				/* not supported yet, treat as next char */
+				ch = *format++;
+				break;
+			default:
+				/* Unknown, skip */
+				break;
+			}
+			ch    = *format++;
+			state = DP_S_DEFAULT;
+			flags = cflags = min = 0;
+			max		     = -1;
+			break;
+		case DP_S_DONE:
+			break;
+		default:
+			/* hmm? */
+			break; /* some picky compilers need this */
+		}
+	}
+	if(maxlen != 0) {
+		if(currlen < maxlen - 1)
+			buffer[currlen] = '\0';
+		else if(maxlen > 0)
+			buffer[maxlen - 1] = '\0';
+	}
+
+	return currlen;
+}
+
+static void fmtstr(char* buffer, size_t* currlen, size_t maxlen,
+		   char* value, int flags, int min, int max) {
+	int padlen, strln; /* amount to pad */
+	int cnt = 0;
+
+#ifdef DEBUG_SNPRINTF
+	printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
+#endif
+	if(value == 0) {
+		value = "<NULL>";
+	}
+
+	for(strln = 0; strln < max && value[strln]; ++strln); /* strlen */
+	padlen = min - strln;
+	if(padlen < 0)
+		padlen = 0;
+	if(flags & DP_F_MINUS)
+		padlen = -padlen; /* Left Justify */
+
+	while((padlen > 0) && (cnt < max)) {
+		dopr_outch(buffer, currlen, maxlen, ' ');
+		--padlen;
+		++cnt;
+	}
+	while(*value && (cnt < max)) {
+		dopr_outch(buffer, currlen, maxlen, *value++);
+		++cnt;
+	}
+	while((padlen < 0) && (cnt < max)) {
+		dopr_outch(buffer, currlen, maxlen, ' ');
+		++padlen;
+		++cnt;
+	}
+}
+
+/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
+
+static void fmtint(char* buffer, size_t* currlen, size_t maxlen,
+		   LLONG value, int base, int min, int max, int flags) {
+	int	       signvalue = 0;
+	unsigned LLONG uvalue;
+	char	       convert[20];
+	int	       place   = 0;
+	int	       spadlen = 0; /* amount to space pad */
+	int	       zpadlen = 0; /* amount to zero pad */
+	int	       caps    = 0;
+
+	if(max < 0)
+		max = 0;
+
+	uvalue = value;
+
+	if(!(flags & DP_F_UNSIGNED)) {
+		if(value < 0) {
+			signvalue = '-';
+			uvalue	  = -value;
+		} else {
+			if(flags & DP_F_PLUS) /* Do a sign (+/i) */
+				signvalue = '+';
+			else if(flags & DP_F_SPACE)
+				signvalue = ' ';
+		}
+	}
+
+	if(flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+
+	do {
+		convert[place++] =
+		    (caps ? "0123456789ABCDEF" : "0123456789abcdef")
+			[uvalue % (unsigned)base];
+		uvalue = (uvalue / (unsigned)base);
+	} while(uvalue && (place < 20));
+	if(place == 20) place--;
+	convert[place] = 0;
+
+	zpadlen = max - place;
+	spadlen = min - MAX(max, place) - (signvalue ? 1 : 0);
+	if(zpadlen < 0) zpadlen = 0;
+	if(spadlen < 0) spadlen = 0;
+	if(flags & DP_F_ZERO) {
+		zpadlen = MAX(zpadlen, spadlen);
+		spadlen = 0;
+	}
+	if(flags & DP_F_MINUS)
+		spadlen = -spadlen; /* Left Justifty */
+
+#ifdef DEBUG_SNPRINTF
+	printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
+	       zpadlen, spadlen, min, max, place);
+#endif
+
+	/* Spaces */
+	while(spadlen > 0) {
+		dopr_outch(buffer, currlen, maxlen, ' ');
+		--spadlen;
+	}
+
+	/* Sign */
+	if(signvalue)
+		dopr_outch(buffer, currlen, maxlen, signvalue);
+
+	/* Zeros */
+	if(zpadlen > 0) {
+		while(zpadlen > 0) {
+			dopr_outch(buffer, currlen, maxlen, '0');
+			--zpadlen;
+		}
+	}
+
+	/* Digits */
+	while(place > 0)
+		dopr_outch(buffer, currlen, maxlen, convert[--place]);
+
+	/* Left Justified spaces */
+	while(spadlen < 0) {
+		dopr_outch(buffer, currlen, maxlen, ' ');
+		++spadlen;
+	}
+}
+
+static LDOUBLE abs_val(LDOUBLE value) {
+	LDOUBLE result = value;
+
+	if(value < 0)
+		result = -value;
+
+	return result;
+}
+
+static LDOUBLE POW10(int exp) {
+	LDOUBLE result = 1;
+
+	while(exp) {
+		result *= 10;
+		exp--;
+	}
+
+	return result;
+}
+
+static LLONG ROUND(LDOUBLE value) {
+	LLONG intpart;
+
+	intpart = (LLONG)value;
+	value	= value - intpart;
+	if(value >= 0.5) intpart++;
+
+	return intpart;
+}
+
+/* a replacement for modf that doesn't need the math library. Should
+   be portable, but slow */
+static double my_modf(double x0, double* iptr) {
+	int    i;
+	long   l;
+	double x = x0;
+	double f = 1.0;
+
+	for(i = 0; i < 100; i++) {
+		l = (long)x;
+		if(l <= (x + 1) && l >= (x - 1)) break;
+		x *= 0.1;
+		f *= 10.0;
+	}
+
+	if(i == 100) {
+		/* yikes! the number is beyond what we can handle. What do we do? */
+		(*iptr) = 0;
+		return 0;
+	}
+
+	if(i != 0) {
+		double i2;
+		double ret;
+
+		ret	= my_modf(x0 - l * f, &i2);
+		(*iptr) = l * f + i2;
+		return ret;
+	}
+
+	(*iptr) = l;
+	return x - (*iptr);
+}
+
+static void fmtfp(char* buffer, size_t* currlen, size_t maxlen,
+		  LDOUBLE fvalue, int min, int max, int flags) {
+	int    signvalue = 0;
+	double ufvalue;
+	char   iconvert[311];
+	char   fconvert[311];
+	int    iplace  = 0;
+	int    fplace  = 0;
+	int    padlen  = 0; /* amount to pad */
+	int    zpadlen = 0;
+	int    caps    = 0;
+	int    idx;
+	double intpart;
+	double fracpart;
+	double temp;
+
+	/*
+	 * AIX manpage says the default is 0, but Solaris says the default
+	 * is 6, and sprintf on AIX defaults to 6
+	 */
+	if(max < 0)
+		max = 6;
+
+	ufvalue = abs_val(fvalue);
+
+	if(fvalue < 0) {
+		signvalue = '-';
+	} else {
+		if(flags & DP_F_PLUS) { /* Do a sign (+/i) */
+			signvalue = '+';
+		} else {
+			if(flags & DP_F_SPACE)
+				signvalue = ' ';
+		}
+	}
+
+#if 0
+	if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+#endif
+
+#if 0
+	 if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
+#endif
+
+	/*
+	 * Sorry, we only support 16 digits past the decimal because of our
+	 * conversion method
+	 */
+	if(max > 16)
+		max = 16;
+
+	/* We "cheat" by converting the fractional part to integer by
+	 * multiplying by a factor of 10
+	 */
+
+	temp = ufvalue;
+	my_modf(temp, &intpart);
+
+	fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
+
+	if(fracpart >= POW10(max)) {
+		intpart++;
+		fracpart -= POW10(max);
+	}
+
+	/* Convert integer part */
+	do {
+		temp = intpart * 0.1;
+		my_modf(temp, &intpart);
+		idx = (int)((temp - intpart + 0.05) * 10.0);
+		/* idx = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
+		/* printf ("%llf, %f, %x\n", temp, intpart, idx); */
+		iconvert[iplace++] =
+		    (caps ? "0123456789ABCDEF" : "0123456789abcdef")[idx];
+	} while(intpart && (iplace < 311));
+	if(iplace == 311) iplace--;
+	iconvert[iplace] = 0;
+
+	/* Convert fractional part */
+	if(fracpart) {
+		do {
+			temp = fracpart * 0.1;
+			my_modf(temp, &fracpart);
+			idx = (int)((temp - fracpart + 0.05) * 10.0);
+			/* idx = (int) ((((temp/10) -fracpart) +0.05) *10); */
+			/* printf ("%lf, %lf, %ld\n", temp, fracpart, idx ); */
+			fconvert[fplace++] =
+			    (caps ? "0123456789ABCDEF" : "0123456789abcdef")[idx];
+		} while(fracpart && (fplace < 311));
+		if(fplace == 311) fplace--;
+	}
+	fconvert[fplace] = 0;
+
+	/* -1 for decimal point, another -1 if we are printing a sign */
+	padlen	= min - iplace - max - 1 - ((signvalue) ? 1 : 0);
+	zpadlen = max - fplace;
+	if(zpadlen < 0) zpadlen = 0;
+	if(padlen < 0)
+		padlen = 0;
+	if(flags & DP_F_MINUS)
+		padlen = -padlen; /* Left Justifty */
+
+	if((flags & DP_F_ZERO) && (padlen > 0)) {
+		if(signvalue) {
+			dopr_outch(buffer, currlen, maxlen, signvalue);
+			--padlen;
+			signvalue = 0;
+		}
+		while(padlen > 0) {
+			dopr_outch(buffer, currlen, maxlen, '0');
+			--padlen;
+		}
+	}
+	while(padlen > 0) {
+		dopr_outch(buffer, currlen, maxlen, ' ');
+		--padlen;
+	}
+	if(signvalue)
+		dopr_outch(buffer, currlen, maxlen, signvalue);
+
+	while(iplace > 0)
+		dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
+
+#ifdef DEBUG_SNPRINTF
+	printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
+#endif
+
+	/*
+	 * Decimal point.  This should probably use locale to find the correct
+	 * char to print out.
+	 */
+	if(max > 0) {
+		dopr_outch(buffer, currlen, maxlen, '.');
+
+		while(zpadlen > 0) {
+			dopr_outch(buffer, currlen, maxlen, '0');
+			--zpadlen;
+		}
+
+		while(fplace > 0)
+			dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
+	}
+
+	while(padlen < 0) {
+		dopr_outch(buffer, currlen, maxlen, ' ');
+		++padlen;
+	}
+}
+
+static void dopr_outch(char* buffer, size_t* currlen, size_t maxlen, char c) {
+	if(*currlen < maxlen) {
+		buffer[(*currlen)] = c;
+	}
+	(*currlen)++;
+}
+
+static int sj4_vsnprintf(char* str, size_t count, const char* fmt, va_list args) {
+	return dopr(str, count, fmt, args);
+}
+
+int sj4_snprintf(char* str, size_t count, const char* fmt, ...) {
+	size_t	ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = sj4_vsnprintf(str, count, fmt, ap);
+	va_end(ap);
+	return ret;
+}

lib/sj4common/sj_string.c

@@ -54,7 +54,7 @@
 #define iseuc(c) ((0xa1 <= (c)) && ((c) <= 0xfe))
 #define iskana(c) ((0xa1 <= (c)) && ((c) <= 0xdf))
 
-int sj4_str_sjistoeuc(unsigned char* out, int outlen, unsigned char* in, unsigned char* sjis_default, int* useflag) {
+int sj4_str_sjistoeuc(unsigned char* out, int outlen, unsigned char* in, int inlen, unsigned char* sjis_default, int* useflag) {
 	unsigned char *sjis = in, *euc = out;
 	int	       n = 0;
 	unsigned short code, default_code;
@@ -65,7 +65,7 @@ int sj4_str_sjistoeuc(unsigned char* out, int outlen, unsigned char* in, unsigne
 	if(!sjis)
 		return 0;
 
-	while(*sjis && n < outlen) {
+	while((sjis - in) < inlen && *sjis && n < (outlen - 1)) {
 		if(issjis1(*sjis)) {
 			code = sjis2euc((*sjis << 8) | *(sjis + 1));
 			if(n + 2 > outlen)
@@ -90,14 +90,14 @@ int sj4_str_sjistoeuc(unsigned char* out, int outlen, unsigned char* in, unsigne
 			sjis++;
 		}
 	}
-	if(n > outlen)
+	if(n > (outlen - 1))
 		return -1;
 
 	euc[n] = '\0';
 	return n;
 }
 
-int sj4_str_euctosjis(unsigned char* out, int outlen, unsigned char* in, unsigned char* sjis_default, int* useflag) {
+int sj4_str_euctosjis(unsigned char* out, int outlen, unsigned char* in, int inlen, unsigned char* sjis_default, int* useflag) {
 	unsigned char *euc = in, *sjis = out;
 	int	       n = 0;
 	unsigned short code, default_code;
@@ -108,7 +108,7 @@ int sj4_str_euctosjis(unsigned char* out, int outlen, unsigned char* in, unsigne
 	if(!euc)
 		return 0;
 
-	while(*euc && n < outlen) {
+	while((euc - in) < inlen && *euc && n < outlen) {
 		if(iseuc(*euc)) {
 			code = euc2sjis((*euc << 8) | *(euc + 1));
 			if(n + 2 > outlen)
@@ -175,13 +175,13 @@ static unsigned char def_char[] = {0x81, 0x40};
 int sj4_sjistoeuc(unsigned char* e, int elen, unsigned char* s, int slen) {
 	int dummy;
 
-	return sj4_str_sjistoeuc(e, elen, s, def_char, &dummy);
+	return sj4_str_sjistoeuc(e, elen, s, slen, def_char, &dummy);
 }
 
 int sj4_euctosjis(unsigned char* s, int slen, unsigned char* e, int elen) {
 	int dummy;
 
-	return sj4_str_euctosjis(s, slen, e, def_char, &dummy);
+	return sj4_str_euctosjis(s, slen, e, elen, def_char, &dummy);
 }
 void sj_euc2sjis(unsigned char* s) {
 	s[0] &= MASK;

lib/sj4common/strlcpy.c

@@ -0,0 +1,52 @@
+/*	$OpenBSD: strlcpy.c,v 1.10 2005/08/08 08:05:37 espie Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, 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.
+ */
+
+/* OPENBSD ORIGINAL: lib/libc/string/strlcpy.c */
+
+#include "sj4compat.h"
+
+#include <string.h>
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t
+sj4_strlcpy(char* dst, const char* src, size_t siz) {
+	char*	    d = dst;
+	const char* s = src;
+	size_t	    n = siz;
+
+	/* Copy as many bytes as will fit */
+	if(n != 0 && --n != 0) {
+		do {
+			if((*d++ = *s++) == 0)
+				break;
+		} while(--n != 0);
+	}
+
+	/* Not enough room in dst, add NUL and traverse rest of src */
+	if(n == 0) {
+		if(siz != 0)
+			*d = '\0'; /* NUL-terminate dst */
+		while(*s++);
+	}
+
+	return (s - src - 1); /* count does not include NUL */
+}

lib/sj4core/adddic.c

@@ -302,7 +302,7 @@ u_int adddic(SJ4_CONTEXT u_char* yomi, u_char* kanji, TypeGram hinsi) {
 
 static int
 checksub(SJ4_CONTEXT u_char* kanji, TypeGram grm) {
-	u_char* tagp;
+	u_char* tagp = NULL;
 	u_char* ptr;
 	u_char* endp;
 	int	flg, nlen;

lib/sj4core/cl2knj.c

@@ -41,7 +41,7 @@ static CLREC *nextrecblk(SJ4_CONTEXT2), *prevrecblk(SJ4_CONTEXT2);
 
 static void initkbuf(SJ4_CONTEXT u_char*);
 
-int cl2knj(SJ4_CONTEXT u_char* yomi, int len, u_char* kouho) {
+int cl2knj(SJ4_CONTEXT u_char* yomi, int len, u_char* kouho, int klen) {
 	u_char* ptr1;
 	u_char* ptr2;
 	int	i;

lib/sj4core/init.c

@@ -85,10 +85,26 @@ Sj4Context* alloccontext(const char* dic) {
 	DictFile*   dict;
 	DICTL*	    node;
 
-	ctx->work = calloc(1, sizeof(*ctx->work));
+	if((ctx->work = calloc(1, sizeof(*ctx->work))) == NULL) {
-	ctx->stdy = calloc(1, sizeof(*ctx->stdy));
+		free(ctx);
+
+		return NULL;
+	}
+	if((ctx->stdy = calloc(1, sizeof(*ctx->stdy))) == NULL) {
+		free(ctx->work);
+		free(ctx);
+
+		return NULL;
+	}
+
+	if((node = calloc(1, sizeof(*node))) == NULL) {
+		free(ctx->stdy);
+		free(ctx->work);
+		free(ctx);
+
+		return NULL;
+	}
 
-	node		     = calloc(1, sizeof(*node));
 	ctx->work->Jdictlist = node;
 
 	initwork(ctx);

lib/sj4core/mk2claus.c

@@ -63,12 +63,12 @@ set2nd(SJ4_CONTEXT CLREC* clrec) {
 static int cost_penalty(CLREC* clrec) {
 	int c = clrec->jnode->cost;
 
-	if(c < 0xfff / 5 * 1) return 8;
+	if(c < 0xfff / 5 * 1) return 0;
-	if(c < 0xfff / 5 * 2) return 4;
+	if(c < 0xfff / 5 * 2) return 1;
 	if(c < 0xfff / 5 * 3) return 2;
-	if(c < 0xfff / 5 * 4) return 1;
+	if(c < 0xfff / 5 * 4) return 4;
-	return 0;
+	return 8;
-};
+}
 
 void mk2claus(SJ4_CONTEXT2) {
 	u_char* keepptr;
@@ -127,7 +127,7 @@ void mk2claus(SJ4_CONTEXT2) {
 
 		if(selcl->cl2len > clrec->cl2len) continue;
 
-		prty = priority(SJ4_CONTEXT_PASS clrec) - prty2 + cost_penalty(clrec);
+		prty = priority(SJ4_CONTEXT_PASS clrec) - prty2 - cost_penalty(clrec);
 
 		prty2++;
 

lib/sj4core/sdepend.c

@@ -60,7 +60,7 @@
 #define ftruncate chsize
 #endif
 
-#ifdef SJ3_GLOBAL
+#ifdef SJ4_GLOBAL
 DictFile* dictlink = NULL;
 StdyFile* stdylink = NULL;
 #else
@@ -174,7 +174,6 @@ getidx(SJ4_CONTEXT DictFile* dp) {
 	idxbuf = dp->buffer + dp->idxstrt;
 	return 0;
 }
-/* XXX: not IFunc */
 static int
 getdic(SJ4_CONTEXT DictFile* dp, TypeDicSeg seg) {
 	if(seg >= dp->dict.segunit) return -1;
@@ -182,10 +181,9 @@ getdic(SJ4_CONTEXT DictFile* dp, TypeDicSeg seg) {
 	return 0;
 }
 static int
-putidx(SJ4_CONTEXT DictFile* dp) {
+putidx(SJ4_CONTEXT DictFile* dp, short dummy) {
 	return putfile(dp->fd, dp->idxstrt, dp->dict.idxlen, idxbuf);
 }
-/* XXX: not IFunc */
 static int
 putdic(SJ4_CONTEXT DictFile* dp, TypeDicSeg seg) {
 	u_char* p;
@@ -213,7 +211,6 @@ putdic(SJ4_CONTEXT DictFile* dp, TypeDicSeg seg) {
 
 	return putfile(dp->fd, i, dp->dict.seglen, p);
 }
-/* XXX: not IFunc */
 static int
 rszdic(SJ4_CONTEXT DictFile* dp, TypeDicSeg seg) {
 	long	i;

src/sj4mkdic/sj4mkdic.h

@@ -26,7 +26,7 @@
 #include <sys/stat.h>
 
 #include "sj4_dict_struct.h"
-#include "sj_compat.h"
+#include "sj4compat.h"
 
 /* char.c */
 int  cnvyomi(int);

src/sj4test/main.c

@@ -26,7 +26,7 @@ int main(int argc, char** argv) {
 		}
 
 		i = 0;
-		while((strlen(c) - i) > 0 && (i += cl2knj(ctx, (u_char*)c + i, strlen(c) - i, (u_char*)out))) {
+		while((strlen(c) - i) > 0 && (i += cl2knj(ctx, (u_char*)c + i, strlen(c) - i, (u_char*)out, sizeof(out) - 1))) {
 			STDYOUT* s = (STDYOUT*)out;
 
 			printf("> %s\n", out + sizeof(STDYOUT));

tools/win32.sh

@@ -67,5 +67,5 @@ library sj4common
 library sj4core
 library sj4rkcv
 
-executable sj4mkdic
+executable sj4mkdic sj4common.lib
 executable sj4test "sj4common.lib sj4core.lib"

tools/wnn2sj4.py

@@ -161,6 +161,6 @@ for y in sorted(grouped.keys()):
 
 	for freq, k, sj, freq in lst:
 		t2 = "\t" * (4 - (len(k) // 4))
-		freq = floor(freq / maxf * 0xffff)
+		freq = 0xffff - floor(freq / maxf * 0xffff)
 		fp.write(f"{y}{t}{k}{t2}{sj}:[C{freq}]:\n")
 fp.close()