diff --git a/ncurses/tinfo/alloc_entry.c b/ncurses/tinfo/alloc_entry.c
index 4638e99..14ea391 100644
--- a/ncurses/tinfo/alloc_entry.c
+++ b/ncurses/tinfo/alloc_entry.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2006,2008 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2012,2013 Free Software Foundation, Inc.              *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
@@ -46,9 +46,8 @@
 #include <curses.priv.h>
 
 #include <tic.h>
-#include <term_entry.h>
 
-MODULE_ID("$Id: alloc_entry.c,v 1.48 2008/08/16 16:25:31 tom Exp $")
+MODULE_ID("$Id: alloc_entry.c,v 1.58 2013/08/17 19:20:38 tom Exp $")
 
 #define ABSENT_OFFSET    -1
 #define CANCELLED_OFFSET -2
@@ -62,43 +61,21 @@
 _nc_init_entry(TERMTYPE *const tp)
 /* initialize a terminal type data block */
 {
-    unsigned i;
-
 #if NO_LEAKS
-    if (tp == 0 && stringbuf != 0) {
-	FreeAndNull(stringbuf);
+    if (tp == 0) {
+	if (stringbuf != 0) {
+	    FreeAndNull(stringbuf);
+	}
 	return;
     }
 #endif
 
     if (stringbuf == 0)
-	stringbuf = (char *) malloc(MAX_STRTAB);
-
-#if NCURSES_XNAMES
-    tp->num_Booleans = BOOLCOUNT;
-    tp->num_Numbers = NUMCOUNT;
-    tp->num_Strings = STRCOUNT;
-    tp->ext_Booleans = 0;
-    tp->ext_Numbers = 0;
-    tp->ext_Strings = 0;
-#endif
-    if (tp->Booleans == 0)
-	tp->Booleans = typeMalloc(NCURSES_SBOOL, BOOLCOUNT);
-    if (tp->Numbers == 0)
-	tp->Numbers = typeMalloc(short, NUMCOUNT);
-    if (tp->Strings == 0)
-	tp->Strings = typeMalloc(char *, STRCOUNT);
-
-    for_each_boolean(i, tp)
-	tp->Booleans[i] = FALSE;
-
-    for_each_number(i, tp)
-	tp->Numbers[i] = ABSENT_NUMERIC;
-
-    for_each_string(i, tp)
-	tp->Strings[i] = ABSENT_STRING;
+	TYPE_MALLOC(char, (size_t) MAX_STRTAB, stringbuf);
 
     next_free = 0;
+
+    _nc_init_termtype(tp);
 }
 
 NCURSES_EXPORT(ENTRY *)
@@ -130,13 +107,13 @@
 	    result = (stringbuf + next_free - 1);
 	}
     } else if (next_free + len < MAX_STRTAB) {
-	strcpy(&stringbuf[next_free], string);
+	_nc_STRCPY(&stringbuf[next_free], string, MAX_STRTAB);
 	DEBUG(7, ("Saved string %s", _nc_visbuf(string)));
 	DEBUG(7, ("at location %d", (int) next_free));
 	next_free += len;
 	result = (stringbuf + old_next_free);
     } else {
-	_nc_warning("Too much data, some is lost");
+	_nc_warning("Too much data, some is lost: %s", string);
     }
     return result;
 }
@@ -181,7 +158,7 @@
 	    } else if (tp->Strings[i] == CANCELLED_STRING) {
 		offsets[i] = CANCELLED_OFFSET;
 	    } else {
-		offsets[i] = tp->Strings[i] - stringbuf;
+		offsets[i] = (int) (tp->Strings[i] - stringbuf);
 	    }
 	}
     }
@@ -190,11 +167,10 @@
 	if (ep->uses[i].name == 0)
 	    useoffsets[i] = ABSENT_OFFSET;
 	else
-	    useoffsets[i] = ep->uses[i].name - stringbuf;
+	    useoffsets[i] = (int) (ep->uses[i].name - stringbuf);
     }
 
-    if ((tp->str_table = typeMalloc(char, next_free)) == (char *) 0)
-	  _nc_err_abort(MSG_NO_MEMORY);
+    TYPE_MALLOC(char, next_free, tp->str_table);
     (void) memcpy(tp->str_table, stringbuf, next_free);
 
     tp->term_names = tp->str_table + n;
@@ -214,17 +190,19 @@
     if (!copy_strings) {
 	if ((n = (unsigned) NUM_EXT_NAMES(tp)) != 0) {
 	    if (n < SIZEOF(offsets)) {
-		unsigned length = 0;
+		size_t length = 0;
+		size_t offset;
 		for (i = 0; i < n; i++) {
 		    length += strlen(tp->ext_Names[i]) + 1;
-		    offsets[i] = tp->ext_Names[i] - stringbuf;
+		    offsets[i] = (int) (tp->ext_Names[i] - stringbuf);
 		}
-		if ((tp->ext_str_table = typeMalloc(char, length)) == 0)
-		      _nc_err_abort(MSG_NO_MEMORY);
-		for (i = 0, length = 0; i < n; i++) {
-		    tp->ext_Names[i] = tp->ext_str_table + length;
-		    strcpy(tp->ext_Names[i], stringbuf + offsets[i]);
-		    length += strlen(tp->ext_Names[i]) + 1;
+		TYPE_MALLOC(char, length, tp->ext_str_table);
+		for (i = 0, offset = 0; i < n; i++) {
+		    tp->ext_Names[i] = tp->ext_str_table + offset;
+		    _nc_STRCPY(tp->ext_Names[i],
+			       stringbuf + offsets[i],
+			       length - offset);
+		    offset += strlen(tp->ext_Names[i]) + 1;
 		}
 	    }
 	}
