/*
 * CDE - Common Desktop Environment
 *
 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
 *
 * These libraries and programs are free software; you can
 * redistribute them and/or modify them under the terms of the GNU
 * Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * These libraries and programs are distributed in the hope that
 * they will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with these libraries and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 */
/* $XConsortium: exksh_tbls.c /main/4 1995/11/01 15:54:33 rswiston $ */
/*	Copyright (c) 1991, 1992 UNIX System Laboratories, Inc. */
/*	All Rights Reserved     */

/*	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF    */
/*	UNIX System Laboratories, Inc.			*/
/*	The copyright notice above does not evidence any       */
/*	actual or intended publication of such source code.    */

#include	"name.h" 
#include	"shell.h" 
#include "stdio.h"
#include <string.h>
#include <sys/types.h>
#include <ctype.h>
#include "exksh.h"
#include "exksh_tbls.h"
#include "exksh_prpar.h"
#include "docall.h"
#include "msgs.h"

int _Delim;
static int strglen;
static int struct_size;

int Pr_tmpnonames = 0;

static const char *Str_close_curly = "}";
static const char *Str_open_curly = "{";

#define MALMEMBERS	(4)	/* initial number of members of malloc'ed array to malloc */

#define UPPER(C) (islower(C) ? toupper(C) : (C))
#define isvarchar(C) (isalnum(C) || ((C) == '_'))

/*
 * Some of our test programs use xk_parse() to parse cdata from command
 * lines.  This has the drawback that anys or externals will get a malloc'ed
 * buffer for their char * on the send side, which would not normally be
 * freed, because xk_free() knows that such any's usually point into the
 * ubuf rather than being malloced.  On the receive side, this would be
 * true even in our test program.  So, on the send side, we keep a table
 * of any any or external char * that is malloc'ed, and xk_free checks
 * this table before free'ing the given item.  After being freed, the
 * stack is decremented for efficiency.
 */

#define ANYTBLINC	(4)

static char **Anytbl = NULL;
static int Nanytbl = 0;
static int Maxanytbl = 0;

struct special {
	char *name;
	int (*free)();
	int (*parse)();
	int (*print)();
};

#define SPEC_FREE	0
#define SPEC_PARSE	1
#define SPEC_PRINT	2

static struct special *Special = NULL;
static int Nspecs = 0;

static char **Dont = NULL;
static int Ndont, Sdont;

int
(*find_special(
        int type,
        char *name ))()
{
	int i;

	if (!Special)
		return(NULL);
	for (i = 0; i < Nspecs; i++) {
		if (strcmp(Special[i].name, name) == 0) {
			switch(type) {
			case SPEC_PRINT:
				return(Special[i].print);
			case SPEC_FREE:
				return(Special[i].free);
			case SPEC_PARSE:
				return(Special[i].parse);
			}
		}
	}
	return(NULL);
}

int
set_special(
        char *name,
        int (*free)(),
        int (*parse)(),
        int (*print)() )
{
	int i;

	for (i = 0; i < Nspecs; i++)
		if (strcmp(Special[i].name, name) == 0)
			break;
	if (i == Nspecs) {
		if (!Special) {
			Special = (struct special *) malloc(sizeof(struct special));
			Special[0].name = strdup(name);
			Nspecs = 1;
		}
		else {
			Special = (struct special *) realloc(Special, (Nspecs + 1) * sizeof(struct special));
			Special[i].name = strdup(name);
			Nspecs++;
		}
	}
	if (!Special)
		return(FAIL);
	Special[i].free = free;
	Special[i].parse = parse;
	Special[i].print = print;
	return(SUCCESS);
}

/*
 * xk_parse:  Takes a pointer to a structure member table, a pointer
 * to a buffer containing an ascii representation of the structure
 * represented by the table pointer, and the number of pointers saved
 * from previous recursive calls to this routine, and parses the
 * buf into p.
 *
 * Increments buf to the last point at which it read a character,
 * and returns SUCCESS or FAIL.
 */

int
xk_parse(
        memtbl_t *tbl,
        char **buf,
        char *p,
        int nptr,
        int sub,
        void *pass,
        memtbl_t *(*tbl_find)() )
{
	memtbl_t *ntbl;
	int i = 0;
	int skind, delim_type;
	long val = 0;		/* used for choice selection */
	char *np;
	int delim = _Delim;
	int nmal;		/* number of members malloc'ed arrays */
	char *pp;
	int (*spec_parse)();
        char * errmsg;

	if (tbl == NULL) {
		if (_Prdebug)
                {
                   errmsg=strdup(GETMESSAGE(8,1, 
                       "xk_parse: A NULL 'type' table was specified\n"));
	 	   fprintf(stderr, errmsg);
                   free(errmsg);
                }
		return(FAIL);
	}
	xk_skipwhite(buf);
	/*
	 * If this is supposed to be a pointer, and we have a string that
	 * starts with "P" and a number then we should take the pointer
	 * itself. This is done by stripping off the 'p' and parsing it as a
	 * unsigned long.
	 *
	 * Further, if it starts with an '&', then we want the address of
	 * a variable, use fsym() to find it.
	 */
	if (((tbl->flags & F_TYPE_IS_PTR) || ((tbl->ptr + nptr) > 0)) &&
		(((UPPER((*buf)[0]) == 'P') && isdigit((*buf)[1])) || ((*buf)[0] == '&'))) {
		if ((*buf)[0] == '&') {
			char *start;

			(*buf)++;
			for (start = *buf; isvarchar(*buf[0]); (*buf)++)
				;
			if ((((unsigned long *) p)[0] = fsym(start, -1)) == NULL)
				return(FAIL);
		}
		else {
			(*buf)++;
			RIF(xk_par_int(buf, (long *)p, pass));
		}
		if (Ndont == Sdont) {
			if (Dont)
				Dont = (char **) realloc(Dont, (Sdont + 20) * sizeof(char *));
			else
				Dont = (char **) malloc((Sdont + 20) * sizeof(char *));
			if (!Dont) {
                           errmsg = strdup(GetSharedMsg(DT_ALLOC_FAILURE));
			   ALTPUTS(errmsg);
                           free(errmsg);
			   exit(1);
			}
			Sdont += 20;
		}
		Dont[Ndont++] = ((char **) p)[0];
		return(SUCCESS);
	}
	if (tbl->tname && (spec_parse = find_special(SPEC_PARSE, tbl->tname)))
		return(spec_parse(tbl, buf, p, nptr, sub, pass, tbl_find));
	if (tbl->name && (spec_parse = find_special(SPEC_PARSE, tbl->name)))
		return(spec_parse(tbl, buf, p, nptr, sub, pass, tbl_find));
	nptr += tbl->ptr;
	if (sub > 0 && tbl->subscr > 0) {
		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,2, 
                         "xk_parse: Multiple array subscripts are not handled in '%s'\n"));
		   fprintf(stderr, errmsg, tbl->name);
                   free(errmsg);
                }
		return(FAIL);
	}
	/*
	 * If there is exactly one pointer associated with this
	 * member, and no length delimiters, and no subscripts,
	 * or there are multiple pointers,
	 * then malloc space for the structure and call ourself
	 * recursively.
	 */
	if ((nptr > 1 && tbl->delim != 0) || (nptr == 1 && tbl->delim == 0 && tbl->subscr == 0)) {
		if (PARPEEK(buf, ",") || PARPEEK(buf, Str_close_curly)) {
			((char **)p)[0] = NULL;
			if (_Prdebug)
                        {
			   errmsg=strdup(GetSharedMsg(DT_XK_PARSE_SET_NULL));
			   fprintf(stderr, errmsg, tbl->name);
                           free(errmsg);
                        }
			return(SUCCESS);
		}
			if (xk_parpeek(buf, "NULL")) {
				RIF(xk_parexpect(buf, "NULL"));
				((char **)p)[0] = NULL;
				if (_Prdebug)
                                {
			           errmsg=strdup(GetSharedMsg(
                                                 DT_XK_PARSE_SET_NULL));
				   fprintf(stderr, errmsg, tbl->name);
                                   free(errmsg);
                                }
				return(SUCCESS);
			}

		if ((((char **)p)[0] = malloc(tbl->size)) == NULL) {
			return(FAIL);
		}
		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,3, 
                        "xk_parse: Setting '%s' to malloc'ed address 0x%x, of size %d\n"));
		   fprintf(stderr,errmsg,tbl->name, ((char **)p)[0], tbl->size);
                   free(errmsg);
                }
		return(xk_parse(tbl, buf, ((char **)p)[0], nptr-1-tbl->ptr, sub, pass, tbl_find));
	}
	/*
	 * If there is exactly one pointer level, or one subscripting level,
	 * and there is a delimiter,
	 * and no subscript, then we are a length delimited malloced array.
	 */
	xk_skipwhite(buf);
	if (tbl->delim != 0 && ((nptr == 1 && tbl->subscr == 0) ||
		(nptr == 0 && tbl->subscr != 0 && tbl->kind != K_STRING))) {

		if (tbl->subscr == 0) {
			if (PARPEEK(buf, ",") || PARPEEK(buf, Str_close_curly)) {
				((char **)p)[0] = NULL;
				if (_Prdebug)
                                {
				   errmsg=strdup(GETMESSAGE(8,4, 
                                     "xk_parse: Setting malloc'ed array '%s' to NULL\n"));
				   fprintf(stderr, errmsg, tbl->name);
                                   free(errmsg);
                                }
				return(SUCCESS);
			}
			if (xk_parpeek(buf, "NULL")) {
				RIF(xk_parexpect(buf, "NULL"));
				((char **)p)[0] = NULL;
				if (_Prdebug)
                                {
				   errmsg=strdup(GetSharedMsg(
                                                    DT_XK_PARSE_SET_NULL));
				   fprintf(stderr, errmsg, tbl->name);
                                   free(errmsg);
                                }
				return(SUCCESS);
			}
			nmal = MALMEMBERS;
			if ((np = malloc(nmal*tbl->size)) == NULL) {
				return(FAIL);
			}
			((char **)p)[0] = np;
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,5, 
                                "xk_parse: Setting member '%s' to malloc'ed pointer 0x%x, of size %d\n"));
			   fprintf(stderr, errmsg, tbl->name, np, 4*tbl->size);
                           free(errmsg);
                        }
		} else {
			np = p;
		}
		xk_skipwhite(buf);
		RIF(PAREXPECT(buf, Str_open_curly));
		*buf += 1;
		i = 0;
		xk_skipwhite(buf);
		while (PARPEEK(buf, Str_close_curly) == FALSE) {
			if (tbl->subscr == 0 && i >= nmal) {
				nmal += MALMEMBERS;
				if((np = realloc(np, nmal*tbl->size)) == NULL) {
					return(FAIL);
				}
				((char **)p)[0] = np;
				if (_Prdebug) {
				   errmsg=strdup(GetSharedMsg(
                                             DT_XK_PARSE_ARRAY_OVERFLOW));
				   fprintf(stderr, errmsg, tbl->name, nmal, nmal*tbl->size);
                                   free(errmsg);
				}
			} else if (tbl->subscr > 0 && i > tbl->subscr) {
				if (_Prdebug)
                                {
				   errmsg=strdup(GETMESSAGE(8,6, 
                                          "xk_parse: The array '%s' overflowed at element number %d\n"));
				   fprintf(stderr, errmsg, tbl->name, i);
                                   free(errmsg);
                                }
			}
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,7, 
                                 "xk_parse: Parsing array element [%d] of '%s' into address 0x%x\n"));
			   fprintf(stderr, errmsg, i, tbl->name, &np[i*tbl->size]);
                           free(errmsg);
                        }
			if (i) {
				xk_skipwhite(buf);
				if (PARPEEK(buf, ",") == FALSE) {
					if (PARPEEK(buf, Str_close_curly) == FALSE) {
						RIF(PAREXPECT(buf, ","));
						*buf += 1;
					}
				}
				else {
					RIF(PAREXPECT(buf, ","));
					*buf += 1;
				}
			}
			RIF(xk_parse(tbl, buf, &np[i*tbl->size], nptr ? -1 : 0,
                                     0, (void *)-1, tbl_find));
			i++;
			struct_size = i;
			xk_skipwhite(buf);
		}
		RIF(PAREXPECT(buf, Str_close_curly));
		*buf += 1;
		return(SUCCESS);
	}
	/*
	 * If there is no delimiter, and there are two levels of pointer,
	 * then we are a NULL terminated array of pointers
	 */
	if (tbl->delim == 0 &&
		((nptr == 2 && sub == 0) || (sub == 1 && nptr == 1))) {
		/*
		 * malloc a few members, realloc as needed
		 */
		nmal = MALMEMBERS;
		if ((((char **)p)[0] = malloc(nmal*tbl->size)) == NULL) {
			return(FAIL);
		}
		xk_skipwhite(buf);
		RIF(PAREXPECT(buf, Str_open_curly));
		*buf += 1;
		xk_skipwhite(buf);
		while (PARPEEK(buf, Str_close_curly) == FALSE) {
			if (i >= nmal) {
				nmal += MALMEMBERS;
				if ((((char **)p)[0] = realloc(((char **)p)[0], nmal*tbl->size)) == NULL) {
					return(FAIL);
				}
				if (_Prdebug) {
				   errmsg=strdup(GetSharedMsg(
                                               DT_XK_PARSE_ARRAY_OVERFLOW));
				   fprintf(stderr, errmsg, tbl->name, nmal, nmal*tbl->size);
                                   free(errmsg);
				}
			}
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,8, 
                             "xk_parse: Parsing array element [%d] of '%s'\n"));
			   fprintf(stderr, errmsg, i, tbl->name);
                           free(errmsg);
                        }
			if (i) {
				RIF(PAREXPECT(buf, ","));
				*buf += 1;
			}
			RIF(xk_parse(tbl, buf, &p[i*tbl->size], 
                                     nptr == 2 ? -2 : -1, 0, (void *)-1, 
                                     tbl_find));

			xk_skipwhite(buf);
		}
		RIF(PAREXPECT(buf, Str_close_curly));
		*buf++;
		((char **)p)[i*tbl->size] = NULL;
		return(SUCCESS);
	}

	switch(tbl->kind) {
	case K_CHAR:
		RIF(xk_par_int(buf, &val, pass));
		((unsigned char *)p)[0] = val;
		break;
	case K_SHORT:
		RIF(xk_par_int(buf, &val, pass));
		((ushort *)p)[0] = val;
		break;
	case K_INT:
		RIF(xk_par_int(buf, &val, pass));
		((int *)p)[0] = val;
		break;
	case K_LONG:
		RIF(xk_par_int(buf, (long *)p, pass));
		break;
	case K_STRING:
		if (tbl->subscr) {
			val = tbl->subscr;
			RIF(xk_par_chararr(buf, (char *)p, (int *)&val));
			if (tbl->delim <= 0 && val > -1) {
				p[val] = '\0';
			}
		} else {
			val = 0;
			RIF(xk_par_charstr(buf, (char **)p, (int *)&val));
			/* If this is not a delimited char string,
			 * then it must be null terminated
			 */
			if (tbl->delim <= 0 && val > -1) {
				((char **) p)[0][val] = '\0';
			}
			strglen = val;
		}
		break;
	case K_TYPEDEF:
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		RIF(xk_parse(ntbl, buf, p, nptr, 0, pass, tbl_find));
		return(SUCCESS);
	case K_STRUCT:
		xk_skipwhite(buf);
		RIF(PAREXPECT(buf, Str_open_curly));
		*buf += 1;
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		pp = NULL;
		for (i = 0; ntbl[i].name != NULL; i++) {
			_Delim = xk_get_pardelim(&ntbl[i], p);
			if (ntbl[i].kind >= K_DSHORT) {
				skind = ntbl[i].kind;
				pp = p + ntbl[i].offset;
				struct_size = 0;
			}
			if (ntbl[i].delim) {
				delim_type = ntbl[i].kind;
			}
			if (i && ntbl[i-1].kind < K_DSHORT) {
				xk_skipwhite(buf);
				if (PARPEEK(buf, ",") == FALSE) {
					if (PARPEEK(buf, Str_close_curly) == FALSE) {
						RIF(PAREXPECT(buf, ","));
						*buf += 1;
					}
				}
				else  {
					RIF(PAREXPECT(buf, ","));
					*buf += 1;
				}
			}
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,9, 
                              "xk_parse: Parsing member '%s' into location 0x%x\n"));
			   fprintf(stderr, errmsg, ntbl[i].name, p + ntbl[i].offset);
                           free(errmsg);
                        }
			if (xk_parse(&ntbl[i], buf, p+ntbl[i].offset, nptr, sub, pass, tbl_find) == FAIL) {
				if (_Prdebug)
                                {
				   errmsg=strdup(GetSharedMsg(
                                                    DT_XK_PARSE_ERROR));
				   fprintf(stderr, errmsg, ntbl[i].name);
                                   free(errmsg);
                                }
				return(FAIL);
			}
		}
		if (pp != NULL) {
			switch(skind) {
				case K_DSHORT:
					if (delim_type == K_STRING)
						((short *)pp)[0] = strglen;
					else
						((short *)pp)[0] = struct_size;
					break;
				case K_DINT:
					if (delim_type == K_STRING)
						((int *)pp)[0] = strglen;
					else
						((int *)pp)[0] = struct_size;
					break;
				case K_DLONG:
					if (delim_type == K_STRING)
						((long *)pp)[0] = strglen;
					else
						((long *)pp)[0] = struct_size;
					break;
				default:
					break;
			}
		}
		xk_skipwhite(buf);
		RIF(PAREXPECT(buf, Str_close_curly));
		*buf += 1;
		break;
	case K_UNION:
		if (strncmp(tbl[-1].name, "ch_", 3) != 0) {
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,10, 
                            "xk_parse: Cannot determine the choice in '%s'\n"));
			   fprintf(stderr, errmsg, tbl->name);
                           free(errmsg);
                        }
			return(FAIL);
		}
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		xk_skipwhite(buf);
		RIF(PAREXPECT(buf, Str_open_curly));
		*buf += 1;
		for (i = 0; ntbl[i].name != NULL; i++) {
			if (xk_parpeek(buf, ntbl[i].name) == TRUE) {
				RIF(xk_parexpect(buf, ntbl[i].name));
				((long *)(p - sizeof(long)))[0] = ntbl[i].choice;
				if (_Prdebug)
                                {
				   errmsg=strdup(GETMESSAGE(8,11, 
                                       "xk_parse: Parsing union member '%s' into location 0x%x\n"));
				   fprintf(stderr, errmsg, ntbl[i].name, p + ntbl[i].offset);
                                   free(errmsg);
                                }
				if (xk_parse(&ntbl[i], buf, p, nptr, sub, pass, tbl_find) == FAIL) {
				   if (_Prdebug)
                                   {
				      errmsg=strdup(GetSharedMsg(
                                                     DT_XK_PARSE_ERROR));
				      fprintf(stderr, errmsg, ntbl[i].name);
                                      free(errmsg);
                                   }
				   return(FAIL);
				}
				break;
			}
		}
		xk_skipwhite(buf);
		RIF(PAREXPECT(buf, Str_close_curly));
		*buf += 1;
		break;
	case K_DSHORT:
	case K_DINT:
	case K_DLONG:
		break;
	default:
		return(FAIL);
	}
	return(SUCCESS);
}

int
xk_get_delim(
        memtbl_t *tbl,
        char *p )
{
	memtbl_t *dtbl = &tbl[tbl->delim];
        char * errmsg;

	if (tbl->delim == 0) {
		return(-1);
	}
	if (_Prdebug)
        {
	   errmsg=strdup(GETMESSAGE(8,12, 
                 "xk_get_delim: The delimiter for field '%s' is field '%s'\n"));
	   fprintf(stderr, errmsg, tbl->name, dtbl->name);
           free(errmsg);
        }
	p += dtbl->offset;
	switch (dtbl->kind) {
	case K_DLONG:
	case K_LONG:
		return(((long *)p)[0]);
	case K_CHAR:
		return(((char *)p)[0]);
	case K_DSHORT:
	case K_SHORT:
		return(((short *)p)[0]);
	case K_DINT:
	case K_INT:
		return(((int *)p)[0]);
	default:
	   if (_Prdebug)
           {
	      errmsg=strdup(GETMESSAGE(8,13, 
                  "xk_get_delim: Cannot find a delimiter value in '%s'\n"));
	      fprintf(stderr, errmsg, tbl->name);
              free(errmsg);
           }
	   return(0);
	}
}


int
xk_get_pardelim(
        memtbl_t *tbl,
        char *p )
{
	memtbl_t *dtbl = &tbl[tbl->delim];
        char * errmsg;

	if (tbl->delim == 0) {
		return(-1);
	}
	if (_Prdebug)
        {
	   errmsg=strdup(GETMESSAGE(8,14, 
              "xk_get_pardelim: The delimiter for field '%s' is field '%s'\n"));
	   fprintf(stderr, errmsg, tbl->name, dtbl->name);
           free(errmsg);
        }
	p += dtbl->offset;
	switch (dtbl->kind) {
	   case K_DLONG:
		return(-1);
	   case K_LONG:
		return(((long *)p)[0]);
	   case K_DSHORT:
		return(-1);
	   case K_CHAR:
		return(((char *)p)[0]);
	   case K_SHORT:
		return(((short *)p)[0]);
	   case K_DINT:
		return(-1);
	   case K_INT:
		return(((int *)p)[0]);
	   default:
	   if (_Prdebug)
           {
	      errmsg=strdup(GETMESSAGE(8,15, 
                 "xk_get_pardelim: Cannot find a delimiter value in '%s'\n"));
	      fprintf(stderr, errmsg, tbl->name);
              free(errmsg);
           }
	   return(0);
	}
}

/*
 * xk_print:  Takes a pointer to a structure member table, a pointer
 * to a buffer big enough to hold an ascii representation of the structure
 * represented by the table pointer, and a pointer to a structure to
 * be filled in, and the number of pointers saved
 * from previous recursive calls to this routine, and prints the
 * buf into p.
 *
 * Increments buf to the last point at which it wrote a character,
 * and returns SUCCESS or FAIL.
 */


int
xk_print(
        memtbl_t *tbl,
        char **buf,
        char *p,
        int nptr,
        int sub,
        void *pass,
        memtbl_t *(*tbl_find)() )
{
	memtbl_t *ntbl;
	int i;
	long val;		/* used for choice selection */
	char *np;
	int delim = _Delim;
	int (*spec_print)();
        char * errmsg;

	if (p == NULL) {
		*buf += lsprintf(*buf, "NULL");
		return(SUCCESS);
	}
	if (tbl == NULL) {
		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,16, 
                       "xk_print: A NULL 'type' table was specified\n"));
		   fprintf(stderr, errmsg);
                   free(errmsg);
                }
		return(FAIL);
	}
	if (tbl->tname && (spec_print = find_special(SPEC_PRINT, tbl->tname)))
		return(spec_print(tbl, buf, p, nptr, sub, pass, tbl_find));
	if (tbl->name && (spec_print = find_special(SPEC_PRINT, tbl->name)))
		return(spec_print(tbl, buf, p, nptr, sub, pass, tbl_find));
	nptr += tbl->ptr;
	if (sub > 0 && tbl->subscr > 0) {
	   if (_Prdebug)
           {
	      errmsg=strdup(GETMESSAGE(8,17, 
              "xk_print: Multiple array subscripts are not handled in '%s'\n"));
	      fprintf(stderr, errmsg, tbl->name);
              free(errmsg);
           }
	   return(FAIL);
	}
	/*
	 * If there is exactly one pointer associated with this
	 * member, and no length delimiters, and no subscripts,
	 * or there are multiple pointers,
	 * then dereference the structure and call ourself
	 * recursively.
	 */
	if ((nptr > 1 && tbl->delim != 0) || (nptr == 1 && tbl->delim == 0 && tbl->subscr == 0)) {
		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,18, 
                          "xk_print: Dereferencing '%s' to address 0x%x\n"));
		   fprintf(stderr, errmsg, tbl->name, ((char **)p)[0]);
                   free(errmsg);
                }
		return(xk_print(tbl, buf, ((char **)p)[0], nptr-1-tbl->ptr, sub, pass, tbl_find));
	}
	/*
	 * If there is exactly one pointer level, or one subscripting level,
	 * and there is a delimiter,
	 * and no subscript, then we are a length delimited array.
	 */
	if (tbl->delim != 0 && ((nptr == 1 && tbl->subscr == 0) ||
		nptr == 0 && tbl->subscr != 0 && tbl->kind != K_STRING)) {

		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,19, 
                             "xk_print: The delimiter for '%s' is %d\n"));
		   fprintf(stderr, errmsg, tbl->name, delim);
                   free(errmsg);
                }
		if (tbl->subscr == 0) {
			np = ((char **)p)[0];
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,20, 
                             "xk_print: Using the pointer 0x%x as an array\n"));
			   fprintf(stderr, errmsg, np);
                           free(errmsg);
                        }
		} else {
			np = p;
		}
		if (np == NULL) {
		 	*buf += lsprintf(*buf, "NULL");
			return(SUCCESS);
		}
		*buf += lsprintf(*buf, Str_open_curly);
		for (i = 0; i < delim; i++) {
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,21, 
                                  "xk_print: Printing array level %d of member '%s' at location 0x%x\n"));
			   fprintf(stderr, errmsg, i, tbl->name, &np[i*tbl->size]);
                           free(errmsg);
                        }
			if (i)
				*buf += lsprintf(*buf, ", ");
			RIF(xk_print(tbl, buf, &np[i*tbl->size], nptr ? -1 : 0,
                            0, (void *)-1, tbl_find));
		}
		*buf += lsprintf(*buf, Str_close_curly);
		return(SUCCESS);
	}
	/*
	 * If there is no delimiter, and there are two levels of pointer,
	 * then we are a NULL terminated array.
	 */
	if (tbl->delim == 0 &&
		((nptr == 2 && sub == 0) || (sub == 1 && nptr == 1))) {
		*buf += lsprintf(*buf, Str_open_curly);
		for (i = 0; ((char **)p)[i*tbl->size] != NULL; i++) {
			if (i)
				*buf += lsprintf(*buf, ", ");
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,22, 
                               "xk_print: Printing array level %d of member '%s'\n"));
			   fprintf(stderr, errmsg, i, tbl->name);
                           free(errmsg);
                        }
			RIF(xk_print(tbl, buf, ((char **)p)[i*tbl->size], 
                                     nptr-(!sub), 0, (void *)-1, tbl_find));
		}
		*buf += lsprintf(*buf, Str_close_curly);
		return(SUCCESS);
	}

	if (!Pr_tmpnonames && (Pr_format & PRNAMES)) {
		switch(tbl->kind) {
		case K_CHAR:
		case K_SHORT:
		case K_INT:
		case K_LONG:
		case K_STRING:
			*buf += lsprintf(*buf, "%s=", tbl->name);
		}
	}
	switch(tbl->kind) {
	case K_CHAR:
	case K_SHORT:
	case K_INT:
	case K_LONG:
		RIF(xk_prin_int(tbl, buf, (unsigned long *)p));
		break;
	case K_STRING:
		if (delim > 0) {
			if (tbl->subscr) {
				RIF(xk_prin_hexstr(buf, (char *)p, delim));
			} else {
				RIF(xk_prin_hexstr(buf, ((char **)p)[0], delim));
			}
		} else {
			if (tbl->subscr) {
				RIF(xk_prin_nts(buf, (char *)p));
			} else {
				RIF(xk_prin_nts(buf, ((char **)p)[0]));
			}
		}
		break;
	case K_TYPEDEF:
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		return(xk_print(ntbl, buf, p, nptr, 0, pass, tbl_find));
	case K_STRUCT:
		*buf += lsprintf(*buf, Str_open_curly);
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		for (i = 0; ntbl[i].name != NULL; i++) {
			_Delim = xk_get_delim(&ntbl[i], p);
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,23, 
                              "xk_print: Printing member '%s' at location 0x%x\n"));
			   fprintf(stderr, errmsg, ntbl[i].name, p+ntbl[i].offset);
                           free(errmsg);
                        }
			RIF(xk_print(&ntbl[i], buf, p+ntbl[i].offset, nptr, sub, pass, tbl_find));
			if (ntbl[i].kind < K_DSHORT && ntbl[i+1].name != NULL)
				*buf += lsprintf(*buf, ", ");
		}
		*buf += lsprintf(*buf, Str_close_curly);
		break;
	case K_UNION:
		if (strncmp(tbl[-1].name, "ch_", 3) != 0) {
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,24, 
                            "xk_print: Cannot determine the choice in '%s'\n"));
			   fprintf(stderr, errmsg, tbl->name);
                           free(errmsg);
                        }
			return(FAIL);
		}
		val = *((long *)(p - sizeof(long)));
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		*buf += lsprintf(*buf, Str_open_curly);
		for (i = 0; ntbl[i].name != NULL; i++) {
			if (ntbl[i].choice == val) {
				*buf += lsprintf(*buf, "%s ", ntbl[i].name);
				if (_Prdebug)
                                {
				   errmsg=strdup(GETMESSAGE(8,25, 
                                      "xk_print: Printing union member '%s' into location 0x%x\n"));
				   fprintf(stderr, errmsg, ntbl[i].name, p + ntbl[i].offset);
                                   free(errmsg);
                                }
				RIF(xk_print(&ntbl[i], buf, p, nptr, sub, pass, tbl_find));
				break;
			}
		}
		*buf += lsprintf(*buf, Str_close_curly);
		break;
	case K_DSHORT:
	case K_DINT:
	case K_DLONG:
		break;
	default:
		return(FAIL);
	}
	return(SUCCESS);
}

/*
 * xk_free:  Takes a pointer to a structure member table, and
 * free any malloc'ec elements in it at all levels.
 * Returns SUCCESS or FAIL.
 *
 * Contains an optimization that if a structure or union contains a
 * type that is a simple type and nptr is zero, does not do a recursive call.
 */

int
xk_free(
        memtbl_t *tbl,
        char *p,
        int nptr,
        int sub,
        memtbl_t *(*tbl_find)() )
{
	memtbl_t *ntbl;
	int i;
	long val;		/* used for choice selection */
	char *np;
	int delim = _Delim;
	int (*spec_free)();
        char * errmsg;

	if (tbl == NULL) {
		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,26, 
                       "xk_free: A NULL 'type' table was specified\n"));
		   fprintf(stderr, errmsg);
                   free(errmsg);
                }
		return(FAIL);
	}
	if (tbl->tname && (spec_free = find_special(SPEC_FREE, tbl->tname)))
		return(spec_free(tbl, p, nptr, sub, tbl_find));
	if (tbl->name && (spec_free = find_special(SPEC_FREE, tbl->name)))
		return(spec_free(tbl, p, nptr, sub, tbl_find));
	nptr += tbl->ptr;
	if ((tbl->flags & F_TYPE_IS_PTR) || (nptr > 0)) {
		for (i = Ndont - 1; i >= 0; i--) {
			if (Dont[i] == ((char **) p)[0]) {
				for ( ; i < Ndont - 1; i++)
					Dont[i] = Dont[i + 1];
				Ndont--;
				return(SUCCESS);
			}
		}
	}
	if (sub > 0 && tbl->subscr > 0) {
		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,27, 
                       "xk_free: Multiple array subscripts are not handled in '%s'\n"));
		   fprintf(stderr, errmsg, tbl->name);
                   free(errmsg);
                }
		return(FAIL);
	}
	/*
	 * If there is exactly one pointer associated with this
	 * member, and no length delimiters, and no subscripts,
	 * or there are multiple pointers,
	 * then recursively call ourselves on the structure, then
	 * free the structure itself.
	 */
	if ((nptr > 1 && tbl->delim != 0) || (nptr == 1 && tbl->delim == 0 && tbl->subscr == 0)) {
		if (((char **)p)[0] != NULL) {
			RIF(xk_free(tbl, ((char **)p)[0], nptr-1-tbl->ptr, sub, tbl_find));
			free(((char **)p)[0]);
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,28, 
                                  "xk_free: The member '%s' at location 0x%x was freed and set to NULL\n"));
			   fprintf(stderr, errmsg, tbl->name, ((char **)p)[0]);
                           free(errmsg);
                        }
			((char **)p)[0] = NULL;
		} else {
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,29, 
                              "xk_free: The member '%s' is NULL; no free occurred\n"));
			   fprintf(stderr, errmsg, tbl->name);
                           free(errmsg);
                        }
		}
		return(SUCCESS);
	}
	/*
	 * If there is exactly one pointer level, or one subscripting level,
	 * and there is a delimiter,
	 * and no subscript, then we are a length delimited malloced array.
	 * Free each element, then free the whole array.
	 */
	if (tbl->delim != 0 && ((nptr == 1 && tbl->subscr == 0) ||
		nptr == 0 && tbl->subscr != 0 && tbl->kind != K_STRING)) {
		if (_Prdebug)
                {
		   errmsg=strdup(GETMESSAGE(8,30, 
                            "xk_free: The delimiter for '%s' is %d\n"));
		   fprintf(stderr, errmsg, tbl->name, delim);
                   free(errmsg);
                }
		if (tbl->subscr == 0)
			np = ((char **)p)[0];
		else
			np = p;
		for (i = 0; i < delim; i++) {
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,31, 
                                "xk_free: Freeing array element [%d] of '%s' at address 0x%x\n"));
			   fprintf(stderr, errmsg, i, tbl->name, &np[i*tbl->size]);
                           free(errmsg);
                        }
			RIF(xk_free(tbl, &np[i*tbl->size], nptr ? -1 : 0, 0, tbl_find));
		}
		if (tbl->subscr == 0) {
			if (np != NULL) {
				if (_Prdebug)
                                {
				   errmsg=strdup(GETMESSAGE(8,32, 
                                       "xk_free: Freeing pointer to array of '%s' at location 0x%x and setting to NULL\n"));
				   fprintf(stderr, errmsg, tbl->name, np);
                                   free(errmsg);
                                }
				free(np);
				if (tbl->subscr == 0)
					((char **)p)[0] = NULL;
			} else if (_Prdebug) {
			   errmsg=strdup(GETMESSAGE(8,33, 
                                 "xk_free: The pointer to array of '%s'is NULL; no free occurred\n"));
			   fprintf(stderr, errmsg, tbl->name);
                           free(errmsg);
                        }
		}
		return(SUCCESS);
	}

	switch(tbl->kind) {
	case K_DSHORT:
	case K_SHORT:
	case K_DINT:
	case K_INT:
	case K_DLONG:
	case K_LONG:
		break;
	case K_STRING:
		if (!tbl->subscr) {
			if (((char **)p)[0] != NULL) {
				if (_Prdebug)
                                {
				   errmsg=strdup(GETMESSAGE(8,34, 
                                      "xk_free: Freeing string '%s' at location 0x%x, and setting to NULL\n"));
				   fprintf(stderr, errmsg, tbl->name, p);
                                   free(errmsg);
                                }
				free(((char **)p)[0]);
				((char **)p)[0] = NULL;
			} else if (_Prdebug) {
			   errmsg=strdup(GETMESSAGE(8,35, 
                                 "xk_free: The string '%s' is NULL; no free occurred\n"));
			   fprintf(stderr, errmsg, tbl->name, p);
                           free(errmsg);
                        }
		}
		break;
	case K_TYPEDEF:
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		return(xk_free(ntbl, p, nptr, 0, tbl_find));
	case K_STRUCT:
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		for (i = 0; ntbl[i].name != NULL; i++) {
			if ((ntbl[i].flags & F_SIMPLE) && nptr+ntbl[i].ptr == 0) {
				if (_Prdebug)
                                {
				   errmsg=strdup(GetSharedMsg(
                                                  DT_XK_FREE_NO_MEMBER));
				   fprintf(stderr, errmsg, ntbl[i].name, p + ntbl[i].offset);
                                   free(errmsg);
                                }
				continue;
			}
			_Delim = xk_get_delim(&ntbl[i], p);
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,36, 
                            "xk_free: Freeing member '%s' at location 0x%x\n"));
			   fprintf(stderr, errmsg, ntbl[i].name, p + ntbl[i].offset);
                           free(errmsg);
                        }
			if (xk_free(&ntbl[i], p+ntbl[i].offset, nptr, sub, tbl_find) == FAIL) {
			   if (_Prdebug)
                           {
			      errmsg=strdup(GETMESSAGE(8,37, 
                                 "xk_free: A failure occurred while freeing the '%s' member\n"));
			      fprintf(stderr, errmsg, ntbl[i].name);
                              free(errmsg);
                           }
			   return(FAIL);
			}
		}
		break;
	case K_UNION:
		if (strncmp(tbl[-1].name, "ch_", 3) != 0) {
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,38, 
                             "xk_free: Cannot determine the choice in '%s'\n"));
			   fprintf(stderr, errmsg, tbl->name);
                           free(errmsg);
                        }
			return(FAIL);
		}
		val = *((long *)(p - sizeof(long)));
		ntbl = tbl_find(tbl->tname, tbl->tbl, tbl->id);
		for (i = 0; ntbl[i].name != NULL; i++) {
			if (ntbl[i].choice == val) {
				if ((ntbl[i].flags & F_SIMPLE) && nptr+ntbl[i].ptr == 0) {
					if (_Prdebug)
                                        {
					   errmsg=strdup(GetSharedMsg(
                                                      DT_XK_FREE_NO_MEMBER));
					   fprintf(stderr, errmsg, ntbl[i].name, p + ntbl[i].offset);
                                           free(errmsg);
                                        }
					continue;
				}
				if (_Prdebug)
                                {
				   errmsg=strdup(GETMESSAGE(8,39, 
                                      "xk_free: Freeing union member '%s' at location 0x%x\n"));
				   fprintf(stderr, errmsg, ntbl[i].name, p + ntbl[i].offset);
                                   free(errmsg);
                                }
				RIF(xk_free(&ntbl[i], p, nptr, sub, tbl_find));
				break;
			}
		}
		if (ntbl[i].name == NULL && _Prdebug)
			if (_Prdebug)
                        {
			   errmsg=strdup(GETMESSAGE(8,40, 
                               "xk_free: There is no legal union choice for '%s' (value is 0x%x); no free occurred\n"));
			   fprintf(stderr, errmsg, tbl->name, val);
                           free(errmsg);
                        }
		break;
	default:
		return(FAIL);
	}
	return(SUCCESS);
}