Rewrite all elstr- functions to take either elstr or string as arguments.

2 files changed, 120 insertions, 127 deletions

diff --git a/src/ellinika/elmorph.c b/src/ellinika/elmorph.c
index 5785f8d..f55e010 100644
--- a/src/ellinika/elmorph.c
+++ b/src/ellinika/elmorph.c
@@ -93,27 +93,30 @@ _elstr_alloc(const char *instr, int syl)
 {
 	struct elstr *elstr;
 	unsigned *wptr;
 	size_t wlen;
 
 	if (utf8_mbstr_to_wc(instr, &wptr, &wlen))
 		return SCM_EOL;
 
 	elstr = scm_gc_malloc(sizeof(*elstr), "Elstr");
 	elstr->str = wptr;
 	elstr->len = wlen;
 	elstr->sylmap = NULL;
+	elstr->nsyl = 0;
+	elstr->acc_syl = 0;
+	elstr->acc_pos = 0;
 	if (syl)
 		_elstr_syllabize(elstr);
-	
+		
 	SCM_RETURN_NEWSMOB(_elstr_tag, elstr);
 }
 
 static SCM
 _elstr_dup(struct elstr *elstr)
 {
 	struct elstr *elnew;
 
 	elnew = scm_gc_malloc(sizeof(*elstr), "Elstr");
 	elnew->str = calloc(elstr->len, sizeof(elnew->str[0]));
 	if (!elnew->str)
 		scm_memory_error("_elstr_dup");
@@ -131,24 +134,26 @@ _elstr_dup(struct elstr *elstr)
 	memcpy(elnew->sylmap, elstr->sylmap,
 	       sizeof(elstr->sylmap[0]) * elstr->nsyl);
 	elnew->acc_syl = elstr->acc_syl;
 	elnew->acc_pos = elstr->acc_pos;
 	SCM_RETURN_NEWSMOB(_elstr_tag, elnew);
 }
 
 static void
 _elstr_concat(struct elstr *dest, struct elstr *src, const char *func_name)
 {
 	unsigned *wp;
 
+	if (src->len == 0)
+		return;
 	wp = realloc(dest->str,
 		     sizeof(dest->str[0]) * (dest->len + src->len));
 	if (!wp)
 		scm_memory_error(func_name);
 	dest->str = wp;
 	memcpy(dest->str + dest->len,
 	       src->str,
 	       sizeof(src->str[0]) * src->len);
 	dest->len += src->len;
 }
 
 static scm_sizet
@@ -210,50 +215,72 @@ _elstr_print(SCM smob, SCM port, scm_print_state *pstate)
 }
 
 static void
 _elstr_init()
 {
     _elstr_tag = scm_make_smob_type("Elstr", sizeof(struct elstr));
     scm_set_smob_free(_elstr_tag, _elstr_free);
     scm_set_smob_print(_elstr_tag, _elstr_print);
 }
 
 #define scm_is_elstr(s) (!SCM_IMP(s) && SCM_CELL_TYPE(s) == _elstr_tag)
 
+static SCM
+force_elstr(struct elstr **ep, SCM scm, int sylopt,
+	    int arg, const char *func_name)
+{
+	struct elstr *elstr;
+	
+	if (scm_is_elstr(scm)) {
+		elstr = (struct elstr*) SCM_CDR(scm);
+	} else {
+		SCM newscm;
+		char *str;
+		
+		SCM_ASSERT(scm_is_string(scm), scm, arg, func_name);
+		str = scm_to_locale_string(scm);
+		newscm = _elstr_alloc(str, sylopt);
+		free(str);
+		if (newscm == SCM_EOL)
+			scm_misc_error(func_name,
+				       "Invalid input string: ~S",
+				       scm_list_1(scm));
+		scm = newscm;
+		elstr = (struct elstr*) SCM_CDR(newscm);
+	}
+	if (ep)
+		*ep = elstr;
+	return scm;
+}
+
+
 SCM_DEFINE_PUBLIC(scm_elstr_p, "elstr?", 1, 0, 0,
 		  (SCM string),
 "Return true if STRING is an elstr\n")
 #define FUNC_NAME s_scm_elstr_p
 {
 	return scm_is_elstr(string) ? SCM_BOOL_T : SCM_BOOL_F;
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_string__elstr, "string->elstr", 1, 0, 0,
 		  (SCM string),
 "Create new ELSTR from STRING\n")
 #define FUNC_NAME s_scm_string__elstr
 {
 	char *str;
 	SCM scm;
 	
 	SCM_ASSERT(scm_is_string(string), string, SCM_ARG1, FUNC_NAME);
-	str = scm_to_locale_string(string);
-	scm = _elstr_alloc(str, 1);
-	free(str);
-	if (scm == SCM_EOL)
-		scm_misc_error(FUNC_NAME,
-			       "Invalid input string: ~S",
-			       scm_list_1(string));
-	return scm;
+	return force_elstr(NULL, string, 1, SCM_ARG1, FUNC_NAME);
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr__string, "elstr->string", 1, 0, 0,
 		  (SCM el),
 "Convert EL to a STRING\n")
 #define FUNC_NAME s_scm_elstr__string
 {
 	struct elstr *elstr;
 	char *s;
 	SCM scm;
 	
@@ -266,113 +293,103 @@ SCM_DEFINE_PUBLIC(scm_elstr__string, "elstr->string", 1, 0, 0,
 	scm = scm_from_locale_string(s);
 	free(s);
 	return scm;
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_length, "elstr-length", 1, 0, 0,
 		  (SCM el),
 "Returns the number of characters in EL\n")
 #define FUNC_NAME s_scm_elstr_length
 {
 	struct elstr *elstr;
-
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
+	force_elstr(&elstr, el, 0, SCM_ARG1, FUNC_NAME);
 	return scm_from_uint(elstr->len);
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_number_of_syllables, "elstr-number-of-syllables",
 		  1, 0, 0,
 		  (SCM el),
 "Returns the number of characters in EL\n")
 #define FUNC_NAME s_scm_elstr_number_of_syllables
 {
 	struct elstr *elstr;
-
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
+	force_elstr(&elstr, el, 1, SCM_ARG1, FUNC_NAME);
 	return scm_from_uint(elstr->nsyl);
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_syllable_prop, "elstr-syllable-prop",
 		  2, 0, 0,
 		  (SCM el, SCM n),
 "Returns properties of the syllable N in EL\n")
 #define FUNC_NAME s_scm_elstr_syllable_prop
 {
 	struct elstr *elstr;
 	unsigned num, start;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
+	force_elstr(&elstr, el, 1, SCM_ARG1, FUNC_NAME);
 	SCM_ASSERT(scm_is_integer(n), n, SCM_ARG2, FUNC_NAME);
 	num = scm_to_uint(n);
 	if (num > elstr->nsyl)
 		scm_misc_error(FUNC_NAME,
 			       "cannot get syllable #~S: not enough syllables: ~S",
 			       scm_list_2(el, n));
 	num = elstr->nsyl - num;
 	if (num == 0)
 		start = 0;
 	else
 		start = elstr->sylmap[num - 1] + 1;
 	
 	return scm_cons(scm_from_uint(start),
 			scm_from_uint(elstr->sylmap[num]));
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_accent_position, "elstr-accent-position", 1, 0, 0,
 		  (SCM el),
 "Return position of the accented character in EL\n")
 #define FUNC_NAME s_scm_elstr_accent_position
 {
 	struct elstr *elstr;
-
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
+	force_elstr(&elstr, el, 0, SCM_ARG1, FUNC_NAME);
 	return scm_from_uint(elstr->acc_pos);
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_accented_syllable, "elstr-accented-syllable",
 		  1, 0, 0,
 		  (SCM el),
 "Return position of the accented syllable in EL\n")
 #define FUNC_NAME s_scm_elstr_accented_syllable
 {
 	struct elstr *elstr;
-
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
+	force_elstr(&elstr, el, 1, SCM_ARG1, FUNC_NAME);
 	return scm_from_uint(elstr->acc_syl);
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_syllable, "elstr-syllable",
 		  2, 0, 0,
 		  (SCM el, SCM n),
 "Return Nth syllable in EL\n")
 #define FUNC_NAME s_scm_elstr_accented_syllable
 {
 	struct elstr *elstr;
 	char *s;
 	SCM scm;
 	unsigned num, start;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
+	force_elstr(&elstr, el, 1, SCM_ARG1, FUNC_NAME);
 	SCM_ASSERT(scm_is_integer(n), n, SCM_ARG2, FUNC_NAME);
 	num = scm_to_uint(n);
 	if (num > elstr->nsyl)
 		scm_misc_error(FUNC_NAME,
 			       "cannot get syllable #~S: not enough syllables: ~S",
 			       scm_list_2(el, n));
 	num = elstr->nsyl - num;
 	if (num == 0)
 		start = 0;
 	else
 		start = elstr->sylmap[num - 1] + 1;
 	if (utf8_wc_to_mbstr(elstr->str + start,
@@ -389,56 +406,58 @@ SCM_DEFINE_PUBLIC(scm_elstr_syllable, "elstr-syllable",
 
 SCM_DEFINE_PUBLIC(scm_elstr_character, "elstr-character",
 		  2, 0, 0,
 		  (SCM el, SCM n),
 "Return Nth character in EL\n")
 #define FUNC_NAME s_scm_elstr_character
 {
 	struct elstr *elstr;
 	unsigned num;
 	char r[6];
 	int len;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
+	force_elstr(&elstr, el, 0, SCM_ARG1, FUNC_NAME);
 	SCM_ASSERT(scm_is_integer(n), n, SCM_ARG2, FUNC_NAME);
 	num = scm_to_uint(n);
 	if (num >= elstr->len)
 		scm_misc_error(FUNC_NAME,
 			       "cannot get character #~S: not enough characters: ~S",
 			       scm_list_2(el, n));
 	len = utf8_wctomb(r, elstr->str[num]);
 	if (len <= 0)
 		scm_misc_error(FUNC_NAME,
 			       "cannot convert elchr to Scheme",
 			       SCM_EOL);
 	r[len] = 0;
 	return scm_from_locale_string(r);
 }
 #undef FUNC_NAME
 
 static SCM
 _elstr_chgcase(SCM el, void (*chgfun)(unsigned *, size_t),
 	       int destructive, const char *func_name)
 {
 	struct elstr *elstr;
 	SCM scm;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
-	elstr = (struct elstr*) SCM_CDR(el);
-	if (destructive)
+	if (destructive) {
+		SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
+		elstr = (struct elstr*) SCM_CDR(el);
 		scm = SCM_UNSPECIFIED;
-	else {
-		scm = _elstr_dup(elstr);
-		elstr = (struct elstr*) SCM_CDR(scm);
+	} else {
+		scm = force_elstr(&elstr, el, 1, SCM_ARG1, func_name);
+		if (scm == el) {
+			scm = _elstr_dup(elstr);
+			elstr = (struct elstr*) SCM_CDR(scm);
+		}
 	}
 	chgfun(elstr->str, elstr->len);
 	return scm;
 }
 
 SCM_DEFINE_PUBLIC(scm_elstr_toupper, "elstr-toupper",
 		  1, 0, 0,
 		  (SCM el),
 "Convert EL to upper case\n")
 #define FUNC_NAME s_scm_elstr_toupper
 {
 	return _elstr_chgcase(el, utf8_wc_strnupper, 0, FUNC_NAME);
@@ -473,31 +492,34 @@ SCM_DEFINE_PUBLIC(scm_elstr_tolower_x, "elstr-tolower!",
 {
 	return _elstr_chgcase(el, utf8_wc_strnlower, 0, FUNC_NAME);
 }
 #undef FUNC_NAME
 
 static SCM
 _elstr_deaccent(SCM el, int destructive, const char *func_name)
 {
 	struct elstr *elstr;
 	unsigned i;
 	SCM scm;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
-	elstr = (struct elstr*) SCM_CDR(el);
-	if (destructive)
+	if (destructive) {
+		SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
 		scm = SCM_UNSPECIFIED;
-	else {
-		scm = _elstr_dup(elstr);
-		elstr = (struct elstr*) SCM_CDR(scm);
+		elstr = (struct elstr*) SCM_CDR(el);
+	} else {
+		scm = force_elstr(&elstr, el, 1, SCM_ARG1, func_name);
+		if (scm == el) {
+			scm = _elstr_dup(elstr);
+			elstr = (struct elstr*) SCM_CDR(scm);
+		}
 	}
 	for (i = 0; i < elstr->len; i++)
 		elstr->str[i] = elchr_deaccent(elstr->str[i]);
 	elstr->acc_pos = 0;
 	elstr->acc_syl = 0;
 	return scm;
 }
 
 SCM_DEFINE_PUBLIC(scm_elstr_deaccent, "elstr-deaccent",
 		  1, 0, 0,
 		  (SCM el),
 "Remove all accents from EL\n")
@@ -517,41 +539,45 @@ SCM_DEFINE_PUBLIC(scm_elstr_deaccent_x, "elstr-deaccent!",
 }
 #undef FUNC_NAME
 
 static SCM
 _elstr_set_accent(SCM el, SCM n, int destructive, const char *func_name)
 {
 	struct elstr *elstr;
 	unsigned i;
 	unsigned acc_num, num, len, start;
 	SCM scm;
 	int dstate;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
+	if (destructive) {
+		SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
+		elstr = (struct elstr*) SCM_CDR(el);
+	} else
+		scm = force_elstr(&elstr, el, 1, SCM_ARG1, func_name);
+
 	SCM_ASSERT(scm_is_integer(n), n, SCM_ARG2, func_name);
-	elstr = (struct elstr*) SCM_CDR(el);
 	num = scm_to_uint(n);
 	if (num > elstr->nsyl)
 		scm_misc_error(func_name,
 			       "cannot set accent on syllable #~S: not enough syllables: ~S",
 			       scm_list_2(el, n));
 	acc_num = elstr->nsyl - num;
 	if (acc_num == 0)
 		start = 0;
 	else
 		start = elstr->sylmap[acc_num - 1] + 1;
 
 	if (destructive)
 		scm = SCM_UNSPECIFIED;
-	else {
+	else if (scm == el) {
 		scm = _elstr_dup(elstr);
 		elstr = (struct elstr*) SCM_CDR(scm);
 	}
 
         /* Clear all accents */
 	for (i = 0; i < elstr->len; i++)
 		elstr->str[i] = elchr_deaccent(elstr->str[i]);
 	len = elstr->sylmap[acc_num] - start + 1;
 	dstate = 0;
 	for (i = start; i <= start + len; i++) {
 		int nstate;
 		
@@ -589,27 +615,26 @@ SCM_DEFINE_PUBLIC(scm_elstr_set_accent_x, "elstr-set-accent!",
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_char_prop_bitmask, "elstr-char-prop-bitmask",
 		  2, 0, 0,
 		  (SCM el, SCM n),
 "Returns properties of the Nth char in EL, as a bitmask\n")
 #define FUNC_NAME s_scm_elstr_char_prop_bitmask
 {
 	struct elstr *elstr;
 	int num;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, FUNC_NAME);
+	force_elstr(&elstr, el, 0, SCM_ARG1, FUNC_NAME);
 	SCM_ASSERT(scm_is_integer(n), n, SCM_ARG2, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(el);
 	num = scm_to_int(n);
 	if (num < 0)
 		num += elstr->len;
 	if (num >= elstr->len)
 		scm_misc_error(FUNC_NAME,
 			       "cannot get character #~S: not enough characters: ~S",
 			       scm_list_2(el, n));
 	return scm_from_uint(elchr_flags(elstr->str[num]));
 }
 #undef FUNC_NAME
 
 static struct deftab {
@@ -675,31 +700,34 @@ SCM_DEFINE_PUBLIC(scm_utf8_tolower, "utf8-tolower", 1, 0, 0,
 	return scm;
 }
 #undef FUNC_NAME
 
 static SCM
 _elstr_thema_aoristoy(SCM el, int destructive, const char *func_name)
 {
 	struct elstr *elstr;
 	SCM scm;
 	unsigned *wc;
 	size_t wclen;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
-	elstr = (struct elstr*) SCM_CDR(el);
-	if (destructive)
+	if (destructive) {
+		SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
+		elstr = (struct elstr*) SCM_CDR(el);
 		scm = SCM_UNSPECIFIED;
-	else {
-		scm = _elstr_dup(elstr);
-		elstr = (struct elstr*) SCM_CDR(scm);
+	} else {
+		scm = force_elstr(&elstr, el, 1, SCM_ARG1, func_name);
+		if (scm == el) {
+			scm = _elstr_dup(elstr);
+			elstr = (struct elstr*) SCM_CDR(scm);
+		}
 	}
 	if (elmorph_thema_aoristoy(elstr->str, elstr->len, &wc, &wclen))
 		scm_memory_error(func_name);
 	free(elstr->str);
 	elstr->str = wc;
 	elstr->len = wclen;
 	return scm;
 }
 
 SCM_DEFINE_PUBLIC(scm_elstr_thema_aoristoy, "elstr-thema-aoristoy", 1, 0, 0,
 		  (SCM thema),
 "Convert THEMA, which must be a root of present. to an aorist root\n")
@@ -717,41 +745,44 @@ SCM_DEFINE_PUBLIC(scm_elstr_thema_aoristoy_x, "elstr-thema-aoristoy!", 1, 0, 0,
 	return _elstr_thema_aoristoy(thema, 1, FUNC_NAME);
 }
 #undef FUNC_NAME
 
 static SCM
 _elstr_slice(SCM el, SCM n, SCM l, int destructive, const char *func_name)
 {
 	struct elstr *elstr;
 	int num;
 	unsigned len;
 	SCM scm;
 	
-	SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
+	if (destructive) {
+		SCM_ASSERT(scm_is_elstr(el), el, SCM_ARG1, func_name);
+		elstr = (struct elstr*) SCM_CDR(el);
+	} else
+		scm = force_elstr(&elstr, el, 1, SCM_ARG1, func_name);
 	SCM_ASSERT(scm_is_integer(n), n, SCM_ARG2, func_name);
 	SCM_ASSERT(scm_is_integer(l), l, SCM_ARG3, func_name);
-	elstr = (struct elstr*) SCM_CDR(el);
 	num = scm_to_int(n);
 	len = scm_to_uint(l);
 	
 	if (num < 0)
 		num += elstr->len;
 	if (num < 0 || num >= elstr->len || num + len > elstr->len)
 		scm_misc_error(func_name,
 			       "invalid offset or length",
 			       SCM_EOL);
 
 	if (destructive)
 		scm = SCM_UNSPECIFIED;
-	else {
+	else if (scm == el) {
 		scm = _elstr_dup(elstr);
 		elstr = (struct elstr*) SCM_CDR(scm);
 	}
 
 	if (num)
 		memmove(elstr->str, elstr->str + num,
 			sizeof(elstr->str[0]) * len);
 	elstr->len = len;
 	_elstr_syllabize(elstr);
 	return scm;
 }
 
@@ -772,128 +803,84 @@ SCM_DEFINE_PUBLIC(scm_elstr_slice_x, "elstr-slice!",
 #define FUNC_NAME s_scm_elstr_slice_x
 {
 	return _elstr_slice(word, off, len, 1, FUNC_NAME);
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_index, "elstr-index",
 		  2, 0, 0,
 		  (SCM word, SCM needle),
 "")
 #define FUNC_NAME s_scm_elstr_index
 {
-	struct elstr *elstr;
-	unsigned *wc, *wtmp = NULL, *p;
-	unsigned wlen;
-	
-	SCM_ASSERT(scm_is_elstr(word), word, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(word);
-	if (scm_is_elstr(needle)) {
-		struct elstr *ep = (struct elstr*) SCM_CDR(needle);
-		wc = ep->str;
-		wlen = ep->len;
-	} else {
-		SCM scm;
-		char *str;
-		
-		SCM_ASSERT(scm_is_string(needle), needle, SCM_ARG2, FUNC_NAME);
-		str = scm_to_locale_string(needle);
-		if (utf8_mbstr_to_wc(str, &wtmp, &wlen)) {
-			free(str);
-			scm_misc_error(FUNC_NAME,
-				       "Invalid needle string: ~S",
-				       scm_list_1(needle));
-		}
-		free(str);
-		wc = wtmp;
-	}
-	p = (unsigned*)utf8_wc_strnstr(elstr->str, elstr->len, wc, wlen);
-	free(wtmp);
+	struct elstr *elstr, *ep;
+	unsigned *p;
+
+	force_elstr(&elstr, word, 0, SCM_ARG1, FUNC_NAME);
+	force_elstr(&ep, needle, 0, SCM_ARG2, FUNC_NAME);
+	p = (unsigned*)utf8_wc_strnstr(elstr->str, elstr->len,
+				       ep->str, ep->len);
 	if (p)
 		return scm_from_int(p - elstr->str);
 	return SCM_BOOL_F;
 }
 #undef FUNC_NAME
 
 static int
-_suffix_matches(struct elstr *elstr, SCM suffix, int arg, const char *func_name)
+_suffix_matches(struct elstr *elstr, struct elstr *ep)
 {
-	struct elstr *ep;
-	
-	if (scm_is_elstr(suffix)) {
-		ep = (struct elstr*) SCM_CDR(suffix);
-	} else {
-		SCM scm;
-		char *str;
-		
-		SCM_ASSERT(scm_is_string(suffix), suffix, arg, func_name);
-		str = scm_to_locale_string(suffix);
-		scm = _elstr_alloc(str, 0);
-		free(str);
-		ep = (struct elstr*) SCM_CDR(scm);
-	}
 	return (ep->len < elstr->len &&
 		memcmp(elstr->str + elstr->len - ep->len,
 		       ep->str,
 		       ep->len * sizeof(elstr->str[0])) == 0);
 }
 
 SCM_DEFINE_PUBLIC(scm_elstr_suffix_p, "elstr-suffix?",
 		  2, 0, 1,
 		  (SCM word, SCM suffix, SCM rest),
 "Return #t if WORDS ends with SUFFIX")
 #define FUNC_NAME s_scm_elstr_suffix_p
 {
-	struct elstr *elstr;
+	struct elstr *elstr, *ep;
 
-	SCM_ASSERT(scm_is_elstr(word), word, SCM_ARG1, FUNC_NAME);
-	elstr = (struct elstr*) SCM_CDR(word);
-	if (_suffix_matches(elstr, suffix, SCM_ARG2, FUNC_NAME))
+	force_elstr(&elstr, word, 0, SCM_ARG1, FUNC_NAME);
+	force_elstr(&ep, suffix, 0, SCM_ARG2, FUNC_NAME);
+	if (_suffix_matches(elstr, ep))
 		return suffix;
 
 	for (; !scm_is_null(rest); rest = SCM_CDR(rest)) {
 		SCM val = SCM_CAR(rest);
-		if (_suffix_matches(elstr, val, SCM_ARGn, FUNC_NAME))
+		force_elstr(&ep, val, 0, SCM_ARGn, FUNC_NAME);
+		if (_suffix_matches(elstr, ep))
 			return val;
 	}
 	return SCM_BOOL_F;
 }
 #undef FUNC_NAME
 
 SCM_DEFINE_PUBLIC(scm_elstr_append, "elstr-append",
 		  0, 0, 1,
 		  (SCM rest),
 "")
 #define FUNC_NAME s_scm_elstr_append
 {
 	SCM ret = _elstr_alloc("", 0);
 	struct elstr *elstr = (struct elstr*) SCM_CDR(ret);
 
 	for (; !scm_is_null(rest); rest = SCM_CDR(rest)) {
+		struct elstr *elt;
 		SCM val = SCM_CAR(rest);
-		if (scm_is_elstr(val)) {
-			struct elstr *elt = (struct elstr*) SCM_CDR(val);
-			_elstr_concat(elstr, elt, FUNC_NAME);
-		} else if (scm_is_string(val)) {
-			char *s = scm_to_locale_string(val);
-			if (s[0]) {
-				SCM tmp = _elstr_alloc(s, 0);
-				free(s);
-				_elstr_concat(elstr,
-					      (struct elstr*) SCM_CDR(tmp),
-					      FUNC_NAME);
-			} else
-				free(s);
-		} else
-			scm_wrong_type_arg(FUNC_NAME, SCM_ARGn, rest);
+
+		force_elstr(&elt, val, 0, SCM_ARGn, FUNC_NAME);
+		_elstr_concat(elstr, elt, FUNC_NAME);
 	}
 	_elstr_syllabize(elstr);
 	return ret;
 }
 #undef FUNC_NAME
 
 
 void
 scm_init_ellinika_elmorph_module()
 {
 	int i;
 	
diff --git a/src/ellinika/elmorph.scm4 b/src/ellinika/elmorph.scm4
index e3ed4b5..f916d1c 100644
--- a/src/ellinika/elmorph.scm4
+++ b/src/ellinika/elmorph.scm4
@@ -12,29 +12,35 @@
 ;;;; 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, see <http://www.gnu.org/licenses/>.
 
 (define-module (ellinika elmorph))
 
 (load-extension
  "LIBDIR/libguile-elmorph-v-VERSION"
  "scm_init_ellinika_elmorph_module")
 
 (define-public (elstr-trim word n)
-  (cond
-   ((> n 0)
-    (elstr-slice word n (- (elstr-length word) n)))
-   ((< n 0)
-    (elstr-slice word 0 (+ (elstr-length word) n)))
-   (else
-    word)))
+  (let ((word (if (string? word)
+		  (string->elstr word)
+		  word)))
+    (cond
+     ((> n 0)
+      (elstr-slice word n (- (elstr-length word) n)))
+     ((< n 0)
+      (elstr-slice word 0 (+ (elstr-length word) n)))
+     (else
+      word))))
 
 (define-public (elstr-trim! word n)
-  (cond
-   ((> n 0)
-    (elstr-slice! word n (- (elstr-length word) n)))
-   ((< n 0)
-    (elstr-slice! word 0 (+ (elstr-length word) n)))))
+  (let ((word (if (string? word)
+		  (string->elstr word)
+		  word)))
+    (cond
+     ((> n 0)
+      (elstr-slice! word n (- (elstr-length word) n)))
+     ((< n 0)
+      (elstr-slice! word 0 (+ (elstr-length word) n))))))