[apple/xnu.git] / osfmk / ddb / db_variables.c

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */
/*
 * 	Author: David B. Golub, Carnegie Mellon University
 *	Date:	7/90
 */

#include <machine/db_machdep.h>
#include <string.h>			/* For strcpy() */

#include <ddb/db_lex.h>
#include <ddb/db_variables.h>
#include <ddb/db_task_thread.h>
#include <ddb/db_sym.h>
#include <ddb/db_command.h>
#include <ddb/db_expr.h>
#include <ddb/db_macro.h>
#include <ddb/db_output.h>		/* For db_printf() */

extern db_expr_t	db_radix;
extern db_expr_t	db_max_width;
extern db_expr_t	db_tab_stop_width;
extern db_expr_t	db_max_line;
extern db_expr_t	db_auto_wrap;
extern db_expr_t	db_macro_level;
extern db_expr_t	db_auto_completion;

#define DB_NWORK	32		/* number of work variable */

db_expr_t	db_work[DB_NWORK];	/* work variable */

struct db_variable db_vars[] = {
	{ "maxoff",	(db_expr_t*)&db_maxoff,	FCN_NULL },
	{ "autowrap",	&db_auto_wrap,		FCN_NULL },
	{ "completion",	&db_auto_completion,	FCN_NULL },
	{ "maxwidth",	&db_max_width,		FCN_NULL },
	{ "radix",	&db_radix,		FCN_NULL },
	{ "tabstops",	&db_tab_stop_width,	FCN_NULL },
	{ "lines",	&db_max_line,		FCN_NULL },
	{ "thr_act",	0,			db_set_default_act	},
	{ "task",	0,			db_get_task_act,
	  1,		2,			-1,	-1		},
	{ "work",	&db_work[0],		FCN_NULL,
	  1,		1,			0,	DB_NWORK-1	},
	{ "arg",	0,			db_arg_variable,
	  1,		1,			1,	DB_MACRO_NARGS,
	  1,		0,	DB_MACRO_LEVEL-1,	(int *)&db_macro_level	},
};
struct db_variable *db_evars = db_vars + sizeof(db_vars)/sizeof(db_vars[0]);


/* Prototypes for functions local to this file.
 */

static char *db_get_suffix(
	register char	*suffix,
	short		*suffix_value);

static boolean_t db_cmp_variable_name(
	struct db_variable		*vp,
	char				*name,
	register db_var_aux_param_t	ap);

static int db_find_variable(
	struct db_variable	**varp,
	db_var_aux_param_t	ap);

static int db_set_variable(db_expr_t value);

void db_list_variable(void);

static char *
db_get_suffix(
	register char	*suffix,
	short		*suffix_value)
{
	register int value;

	for (value = 0; *suffix && *suffix != '.' && *suffix != ':'; suffix++) {
	    if (*suffix < '0' || *suffix > '9')
		return(0);
	    value = value*10 + *suffix - '0';
	}
	*suffix_value = value;
	if (*suffix == '.')
	    suffix++;
	return(suffix);
}

static boolean_t
db_cmp_variable_name(
	struct db_variable		*vp,
	char				*name,
	register db_var_aux_param_t	ap)
{
	register char *var_np, *np;
	register int level;
	
	for (np = name, var_np = vp->name; *var_np; ) {
	    if (*np++ != *var_np++)
		return(FALSE);
	}
	for (level = 0; *np && *np != ':' && level < vp->max_level; level++){
	    if ((np = db_get_suffix(np, &ap->suffix[level])) == 0)
		return(FALSE);
	}
	if ((*np && *np != ':') || level < vp->min_level
	    || (level > 0 && (ap->suffix[0] < vp->low 
		  	      || (vp->high >= 0 && ap->suffix[0] > vp->high))))
	    return(FALSE);
	strcpy(ap->modif, (*np)? np+1: "");
	ap->thr_act = (db_option(ap->modif, 't')?db_default_act: THREAD_NULL);
	ap->level = level;
	ap->hidden_level = -1;
	return(TRUE);
}

static int
db_find_variable(
	struct db_variable	**varp,
	db_var_aux_param_t	ap)
{
	int	t;
	struct db_variable *vp;

	t = db_read_token();
	if (t == tIDENT) {
	    for (vp = db_vars; vp < db_evars; vp++) {
		if (db_cmp_variable_name(vp, db_tok_string, ap)) {
		    *varp = vp;
		    return (1);
		}
	    }
	    for (vp = db_regs; vp < db_eregs; vp++) {
		if (db_cmp_variable_name(vp, db_tok_string, ap)) {
		    *varp = vp;
		    return (1);
		}
	    }
#if defined(ALTERNATE_REGISTER_DEFS)
	    for (vp = db_altregs; vp < db_ealtregs; vp++) {
		if (db_cmp_variable_name(vp, db_tok_string, ap)) {
		    *varp = vp;
		    return (1);
		}
	    }
#endif /* defined(ALTERNATE_REGISTER_DEFS) */
	}
	db_printf("Unknown variable \"$%s\"\n", db_tok_string);
	db_error(0);
	return (0);
}

int
db_get_variable(db_expr_t *valuep)
{
	struct db_variable *vp;
	struct db_var_aux_param aux_param;
	char		modif[TOK_STRING_SIZE];

	aux_param.modif = modif;
	if (!db_find_variable(&vp, &aux_param))
	    return (0);

	db_read_write_variable(vp, valuep, DB_VAR_GET, &aux_param);

	return (1);
}

static int
db_set_variable(db_expr_t value)
{
	struct db_variable *vp;
	struct db_var_aux_param aux_param;
	char		modif[TOK_STRING_SIZE];

	aux_param.modif = modif;
	if (!db_find_variable(&vp, &aux_param))
	    return (0);

	db_read_write_variable(vp, &value, DB_VAR_SET, &aux_param);

	return (1);
}

void
db_read_write_variable(
	struct db_variable	*vp,
	db_expr_t		*valuep,
	int 			rw_flag,
	db_var_aux_param_t	ap)
{
	int	(*func)(struct db_variable*, db_expr_t*,int, db_var_aux_param_t)
			= vp->fcn;
	struct  db_var_aux_param aux_param;
	db_expr_t old_value;

	if (ap == 0) {
	    ap = &aux_param;
	    ap->modif = "";
	    ap->level = 0;
	    ap->thr_act = THREAD_NULL;
	}
	if (rw_flag == DB_VAR_SET && vp->precious)
		db_read_write_variable(vp, &old_value, DB_VAR_GET, ap);
	if (func == FCN_NULL) {
	    if (rw_flag == DB_VAR_SET)
	        vp->valuep[(ap->level)? (ap->suffix[0] - vp->low): 0] = *valuep;
	    else
	        *valuep = vp->valuep[(ap->level)? (ap->suffix[0] - vp->low): 0];
	} else
	    (*func)(vp, valuep, rw_flag, ap);
	if (rw_flag == DB_VAR_SET && vp->precious)
		db_printf("\t$%s:%s<%#x>\t%#8lln\t=\t%#8lln\n", vp->name,
			  ap->modif, ap->thr_act, (unsigned long long)old_value, (unsigned long long)*valuep);
}

void
db_list_variable(void)
{
	register struct db_variable *new;
	register struct db_variable *old;
	register struct db_variable *cur;
	unsigned int l;
	unsigned int len;
	short i;
	unsigned int j;

	len = 1;
	for (cur = db_vars; cur < db_evars; cur++) {
	    if (cur->min_level > 0 || cur->max_level > 0) {
		j = 3 * (cur->max_level - cur->min_level + 1) - 1;
		if (cur->max_level > cur->min_level)
		    j += 2;
	    } else
		j = 0;
	    if ((l = strlen(cur->name) + j) >= len)
		len = l + 1;
	}

	old = (struct db_variable *)0;
	for (;;) {
	    new = (struct db_variable *)0;
	    for (cur = db_vars; cur < db_evars; cur++)
		if ((new == (struct db_variable *)0 ||
		     strcmp(cur->name, new->name) < 0) &&
		    (old == (struct db_variable *)0 ||
		     strcmp(cur->name, old->name) > 0))
		    new = cur;
	    if (new == (struct db_variable *)0)
		    return;
	    db_reserve_output_position(len);
	    db_printf(new->name);
	    j = strlen(new->name);
	    if (new->min_level > 0) {
		db_putchar('?');
		db_putchar('?');
		j += 2;
		for (i = new->min_level - 1; i > 0; i--) {
		    db_putchar('.');
		    db_putchar('?');
		    db_putchar('?');
		    j += 3;
		}
		if (new->max_level > new->min_level) {
		    db_putchar('[');
		    db_putchar('.');
		    db_putchar('?');
		    db_putchar('?');
		    j += 4;
		}
		i = new->min_level + 1;
	    } else {
		if (new->max_level > new->min_level) {
		    db_putchar('[');
		    j++;
		}
		i = new->min_level;
	    }
	    while (i++ < new->max_level) {
		 db_putchar('.');
		 db_putchar('?');
		 db_putchar('?');
		 j += 3;
	    }
	    if (new->max_level > new->min_level) {
		 db_putchar(']');
		 j++;
	    }
	    while (j++ < len)
		    db_putchar(' ');
	    old = new;
	}
}

void
db_set_cmd(void)
{
	db_expr_t	value;
	int		t;
	struct db_variable *vp;
	struct db_var_aux_param aux_param;
	char		modif[TOK_STRING_SIZE];

	aux_param.modif = modif;
	t = db_read_token();
	if (t == tIDENT && strcmp("help", db_tok_string) == 0) {
		db_list_variable();
		return;
	}
	if (t != tDOLLAR) {
	    db_error("Variable name should be prefixed with $\n");
	    return;
	}
	if (!db_find_variable(&vp, &aux_param)) {
	    db_error("Unknown variable\n");
	    return;
	}

	t = db_read_token();
	if (t != tEQ)
	    db_unread_token(t);

	if (!db_expression(&value)) {
	    db_error("No value\n");
	    return;
	}
	if ((t = db_read_token()) == tSEMI_COLON)
	    db_unread_token(t);
	else if (t != tEOL)
	    db_error("?\n");

	db_read_write_variable(vp, &value, DB_VAR_SET, &aux_param);
}

void
db_show_one_variable(void)
{
	struct db_variable *cur;
	unsigned int len;
	unsigned int sl;
	unsigned int slen;
	short h;
	short i;
	short j;
	short k;
	short low;
	int hidden_level;
	struct db_var_aux_param aux_param;
	char *p;
	char *q;
	char *name;
	db_addr_t offset;

	for (cur = db_vars; cur < db_evars; cur++)
	    if (db_cmp_variable_name(cur, db_tok_string, &aux_param))
		break;
	if (cur == db_evars) {
	    for (cur = db_vars; cur < db_evars; cur++) {
		for (q = cur->name, p = db_tok_string; *q && *p == *q; p++,q++)
		    continue;
		if (*q == '\0')
		    break;
	    }
	    if (cur == db_evars) {
		db_error("Unknown variable\n");
		return;
	    }

	    for (i = 0; *p && *p != ':' && i < cur->max_level; i++, p = q)
		if ((q = db_get_suffix(p, &aux_param.suffix[i])) == 0)
		    break;
	    aux_param.level = i;
	    if ((*p && *p != ':') ||
		(i > 0 && (aux_param.suffix[0] < cur->low  ||
			   (cur->high >= 0 &&
			    aux_param.suffix[0] > cur->high)))) {
		db_error("Unknown variable format\n");
		return;
	    }

	    strcpy(aux_param.modif, *p ? p + 1 : "");
	    aux_param.thr_act = (db_option(aux_param.modif, 't') ?
			db_default_act : THREAD_NULL);
	}

	if (cur->hidden_level)
	    if (*cur->hidden_levelp >= cur->hidden_low &&
		*cur->hidden_levelp <= cur->hidden_high) {
		hidden_level = 1;
		aux_param.hidden_level = h = *cur->hidden_levelp;
	    } else {
		hidden_level = 0;
		aux_param.hidden_level = h = cur->hidden_low;
		slen = 1;
		for (k = aux_param.level > 0 ? aux_param.suffix[0] : cur->high;
		     k > 9; k /= 10)
		    slen++;
	    }
	else
	    aux_param.hidden_level = -1;

	if ((cur->min_level == 0 && !cur->hidden_level) || cur->high < 0)
	    j = 0;
	else {
	    if (cur->min_level > 0) {
		j = 1;
		for (k = aux_param.level > 0 ?
		     aux_param.suffix[0] : cur->high; k > 9; k /= 10)
		    j++;
	    } else
		j = 0;
	    if (cur->hidden_level && hidden_level == 0) {
		j += 3;
		for (k = aux_param.hidden_level >= 0 ?
		     aux_param.hidden_level : cur->hidden_high; k > 9; k /= 10)
		    j++;
	    }
	}
	len = strlen(cur->name) + j;
	i = low = aux_param.level > 0 ? aux_param.suffix[0] : cur->low;

	for (;;) {
	    db_printf(cur->name);
	    j = strlen(cur->name);
	    if (cur->high >= 0) {
		if (cur->min_level > 0) {
		    db_printf("%d", i);
		    j++;
		    for (k = i; k > 9; k /= 10)
			j++;
		}
		if (cur->hidden_level && hidden_level == 0) {
		    sl = 1;
		    for (k = i; k > 9; k /= 10)
			sl++;
		    while (sl++ < slen) {
			db_putchar(' ');
			j++;
		    }
		    db_printf("[%d]", h);
		    j += 3;
		    for (k = h; k > 9; k /= 10)
			j++;
		}
	    }

	    while (j++ < len)
		db_putchar(' ');
	    db_putchar(':');
	    db_putchar(' ');

	    if (cur->fcn) {
		aux_param.suffix[0] = i;
		(*cur->fcn)(cur, (db_expr_t *)0, DB_VAR_SHOW, &aux_param);
	    } else {
		db_printf("%#lln", (unsigned long long)*(cur->valuep + i));
	        db_find_xtrn_task_sym_and_offset(*(cur->valuep + i), &name,
						 &offset, TASK_NULL);
		if (name != (char *)0 && offset <= db_maxoff &&
		    offset != *(cur->valuep + i)) {
		    db_printf("\t%s", name);
		    if (offset != 0)
			db_printf("+%#llr", (unsigned long long)offset);
		}
	    }
	    db_putchar('\n');
	    if (cur->high < 0)
		break;
	    if (aux_param.level > 0 || i++ == cur->high) {
		if (!cur->hidden_level ||
		    hidden_level == 0 ||
		    h++ == cur->hidden_high)
		    break;
		aux_param.hidden_level = h;
		i = low;
	    }
	}
}

void
db_show_variable(void)
{
	struct db_variable *cur;
	unsigned int l;
	unsigned int len;
	unsigned int sl;
	unsigned int slen;
	short h;
	short i;
	short j;
	short k;
	int t;
	int t1;
	struct db_var_aux_param aux_param;
	char *name;
	db_addr_t offset;

	switch(t = db_read_token()) {
	case tEOL:
	case tEOF:
	case tSEMI_COLON:
	    break;

	case tDOLLAR:
	    t1 = db_read_token();
	    if (t1 == tIDENT) {
		db_show_one_variable();
		return;
	    }
	    db_error("Not a variable name after $\n");
	    db_unread_token(t);
	    return;

	default:
	    db_error("Variable name should be prefixed with $\n");
	    db_unread_token(t);
	    return;
	}
	db_unread_token(t);

	slen = len = 1;
	for (cur = db_vars; cur < db_evars; cur++) {
	    if ((cur->min_level == 0 && !cur->hidden_level) || cur->high < 0)
		j = 0;
	    else {
		if (cur->min_level > 0) {
		    j = 1;
		    for (k = cur->high; k > 9; k /= 10)
			j++;
		} else
		    j = 0;
		if (cur->hidden_level &&
		    (*cur->hidden_levelp < cur->hidden_low ||
		     *cur->hidden_levelp > cur->hidden_high)) {
		    j += 3;
		    for (k = cur->hidden_high; k > 9; k /= 10)
			j++;
		}
	    }
	    if ((l = strlen(cur->name) + j) >= len)
		len = l + 1;
	}

	aux_param.modif = "";
	aux_param.level = 1;
	aux_param.thr_act = THREAD_NULL;

	for (cur = db_vars; cur < db_evars; cur++) {
	    i = cur->low;
	    if (cur->hidden_level) {
		if (*cur->hidden_levelp >= cur->hidden_low &&
		    *cur->hidden_levelp <= cur->hidden_high) {
		    h = cur->hidden_low - 1;
		    aux_param.hidden_level = *cur->hidden_levelp;
		} else {
		    h = cur->hidden_low;
		    aux_param.hidden_level = cur->hidden_low;
		}
		slen = 1;
		for (k = cur->high; k > 9; k /= 10)
		    slen++;
	    } else
		aux_param.hidden_level = -1;

	    if (cur != db_vars && cur->high >= 0 &&
		(cur->min_level > 0 || cur->hidden_level))
		    db_putchar('\n');

	    for (;;) {
		db_printf(cur->name);
		j = strlen(cur->name);
		if (cur->high >= 0) {
		    if (cur->min_level > 0) {
			db_printf("%d", i);
			j++;
			for (k = i; k > 9; k /= 10)
			    j++;
		    }
		    if (cur->hidden_level && h >= cur->hidden_low) {
			sl = 1;
			for (k = i; k > 9; k /= 10)
			    sl++;
			while (sl++ < slen) {
			    db_putchar(' ');
			    j++;
			}
			db_printf("[%d]", h);
			j += 3;
			for (k = h; k > 9; k /= 10)
			    j++;
		    }
		}
		while (j++ < len)
		    db_putchar(' ');
		db_putchar(':');
		db_putchar(' ');

		if (cur->fcn) {
		    aux_param.suffix[0] = i;
		    (*cur->fcn)(cur, (db_expr_t *)0, DB_VAR_SHOW, &aux_param);
		} else {
		    db_printf("%#lln", (unsigned long long)*(cur->valuep + i));
		    db_find_xtrn_task_sym_and_offset(*(cur->valuep + i), &name,
						     &offset, TASK_NULL);
		    if (name != (char *)0 && offset <= db_maxoff &&
			offset != *(cur->valuep + i)) {
			db_printf("\t%s", name);
			if (offset != 0)
			    db_printf("+%#llr", (unsigned long long)offset);
		    }
		}
		db_putchar('\n');
		if (cur->high < 0)
		    break;
		if (i++ == cur->high) {
		    if (!cur->hidden_level || h++ == cur->hidden_high)
			break;
		    aux_param.hidden_level = h;
		    i = cur->low;
		}
	    }
	}
}

/*
 * given a name of a machine register, return a variable pointer to it.
 */
db_variable_t
db_find_reg_name(
	char	*s)
{
	register db_variable_t	regp;

	if ( s == (char *)0 )
		return DB_VAR_NULL;

	for (regp = db_regs; regp < db_eregs; regp++) {
		if ( strcmp( s, regp->name) == 0 )
			return regp;
	}
	return DB_VAR_NULL;
}
Commit	Line	Data
1c79356b	1	/*
91447636	2	* Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
8f6c56a5 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_COPYRIGHT@
	30	*/
1c79356b A	31	/*
	32	* Mach Operating System
	33	* Copyright (c) 1991,1990 Carnegie Mellon University
	34	* All Rights Reserved.
	35	*
	36	* Permission to use, copy, modify and distribute this software and its
	37	* documentation is hereby granted, provided that both the copyright
	38	* notice and this permission notice appear in all copies of the
	39	* software, derivative works or modified versions, and any portions
	40	* thereof, and that both notices appear in supporting documentation.
	41	*
	42	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	43	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	44	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	45	*
	46	* Carnegie Mellon requests users of this software to return to
	47	*
	48	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	49	* School of Computer Science
	50	* Carnegie Mellon University
	51	* Pittsburgh PA 15213-3890
	52	*
	53	* any improvements or extensions that they make and grant Carnegie Mellon
	54	* the rights to redistribute these changes.
	55	*/
	56	/*
	57	*/
	58	/*
	59	* Author: David B. Golub, Carnegie Mellon University
	60	* Date: 7/90
	61	*/
	62
	63	#include <machine/db_machdep.h>
	64	#include <string.h> /* For strcpy() */
	65
	66	#include <ddb/db_lex.h>
	67	#include <ddb/db_variables.h>
	68	#include <ddb/db_task_thread.h>
	69	#include <ddb/db_sym.h>
	70	#include <ddb/db_command.h>
	71	#include <ddb/db_expr.h>
	72	#include <ddb/db_macro.h>
	73	#include <ddb/db_output.h> /* For db_printf() */
	74
	75	extern db_expr_t db_radix;
	76	extern db_expr_t db_max_width;
	77	extern db_expr_t db_tab_stop_width;
	78	extern db_expr_t db_max_line;
	79	extern db_expr_t db_auto_wrap;
	80	extern db_expr_t db_macro_level;
	81	extern db_expr_t db_auto_completion;
	82
	83	#define DB_NWORK 32 /* number of work variable */
	84
	85	db_expr_t db_work[DB_NWORK]; /* work variable */
	86
	87	struct db_variable db_vars[] = {
	88	{ "maxoff", (db_expr_t*)&db_maxoff, FCN_NULL },
	89	{ "autowrap", &db_auto_wrap, FCN_NULL },
	90	{ "completion", &db_auto_completion, FCN_NULL },
	91	{ "maxwidth", &db_max_width, FCN_NULL },
	92	{ "radix", &db_radix, FCN_NULL },
	93	{ "tabstops", &db_tab_stop_width, FCN_NULL },
	94	{ "lines", &db_max_line, FCN_NULL },
95	{ "thr_act", 0, db_set_default_act },
96	{ "task", 0, db_get_task_act,
97	1, 2, -1, -1 },
98	{ "work", &db_work[0], FCN_NULL,
99	1, 1, 0, DB_NWORK-1 },
100	{ "arg", 0, db_arg_variable,
101	1, 1, 1, DB_MACRO_NARGS,
102	1, 0, DB_MACRO_LEVEL-1, (int *)&db_macro_level },
103	};
104	struct db_variable *db_evars = db_vars + sizeof(db_vars)/sizeof(db_vars[0]);
105
106
107
108	/* Prototypes for functions local to this file.
109	*/
110
111	static char *db_get_suffix(
112	register char *suffix,
113	short *suffix_value);
114
115	static boolean_t db_cmp_variable_name(
116	struct db_variable *vp,
117	char *name,
118	register db_var_aux_param_t ap);
119
120	static int db_find_variable(
121	struct db_variable **varp,
122	db_var_aux_param_t ap);
123
124	static int db_set_variable(db_expr_t value);
125
126	void db_list_variable(void);
127
128	static char *
129	db_get_suffix(
130	register char *suffix,
131	short *suffix_value)
132	{
133	register int value;
134
135	for (value = 0; suffix && suffix != '.' && *suffix != ':'; suffix++) {
136	if (suffix < '0' \|\| suffix > '9')
137	return(0);
138	value = value10 + suffix - '0';
139	}
140	*suffix_value = value;
141	if (*suffix == '.')
142	suffix++;
143	return(suffix);
144	}
145
146	static boolean_t
147	db_cmp_variable_name(
148	struct db_variable *vp,
149	char *name,
150	register db_var_aux_param_t ap)
151	{
152	register char var_np, np;
153	register int level;
154
155	for (np = name, var_np = vp->name; *var_np; ) {
156	if (np++ != var_np++)
157	return(FALSE);
158	}
159	for (level = 0; np && np != ':' && level < vp->max_level; level++){
160	if ((np = db_get_suffix(np, &ap->suffix[level])) == 0)
161	return(FALSE);
162	}
163	if ((np && np != ':') \|\| level < vp->min_level
164	\|\| (level > 0 && (ap->suffix[0] < vp->low
165	\|\| (vp->high >= 0 && ap->suffix[0] > vp->high))))
166	return(FALSE);
167	strcpy(ap->modif, (*np)? np+1: "");
91447636	168	ap->thr_act = (db_option(ap->modif, 't')?db_default_act: THREAD_NULL);
1c79356b A	169	ap->level = level;
	170	ap->hidden_level = -1;
	171	return(TRUE);
	172	}
	173
	174	static int
	175	db_find_variable(
	176	struct db_variable **varp,
	177	db_var_aux_param_t ap)
	178	{
	179	int t;
	180	struct db_variable *vp;
	181
	182	t = db_read_token();
	183	if (t == tIDENT) {
	184	for (vp = db_vars; vp < db_evars; vp++) {
	185	if (db_cmp_variable_name(vp, db_tok_string, ap)) {
	186	*varp = vp;
	187	return (1);
	188	}
	189	}
	190	for (vp = db_regs; vp < db_eregs; vp++) {
	191	if (db_cmp_variable_name(vp, db_tok_string, ap)) {
	192	*varp = vp;
	193	return (1);
	194	}
	195	}
	196	#if defined(ALTERNATE_REGISTER_DEFS)
	197	for (vp = db_altregs; vp < db_ealtregs; vp++) {
	198	if (db_cmp_variable_name(vp, db_tok_string, ap)) {
	199	*varp = vp;
	200	return (1);
	201	}
	202	}
	203	#endif /* defined(ALTERNATE_REGISTER_DEFS) */
	204	}
	205	db_printf("Unknown variable \"$%s\"\n", db_tok_string);
	206	db_error(0);
	207	return (0);
	208	}
	209
	210	int
	211	db_get_variable(db_expr_t *valuep)
	212	{
	213	struct db_variable *vp;
	214	struct db_var_aux_param aux_param;
	215	char modif[TOK_STRING_SIZE];
	216
	217	aux_param.modif = modif;
	218	if (!db_find_variable(&vp, &aux_param))
	219	return (0);
	220
	221	db_read_write_variable(vp, valuep, DB_VAR_GET, &aux_param);
	222
	223	return (1);
	224	}
	225
	226	static int
	227	db_set_variable(db_expr_t value)
	228	{
	229	struct db_variable *vp;
	230	struct db_var_aux_param aux_param;
	231	char modif[TOK_STRING_SIZE];
	232
233	aux_param.modif = modif;
234	if (!db_find_variable(&vp, &aux_param))
235	return (0);
236
237	db_read_write_variable(vp, &value, DB_VAR_SET, &aux_param);
238
239	return (1);
240	}
241
242	void
243	db_read_write_variable(
244	struct db_variable *vp,
245	db_expr_t *valuep,
246	int rw_flag,
247	db_var_aux_param_t ap)
248	{
249	int (func)(struct db_variable, db_expr_t*,int, db_var_aux_param_t)
250	= vp->fcn;
251	struct db_var_aux_param aux_param;
252	db_expr_t old_value;
253
254	if (ap == 0) {
255	ap = &aux_param;
256	ap->modif = "";
257	ap->level = 0;
91447636	258	ap->thr_act = THREAD_NULL;
1c79356b A	259	}
	260	if (rw_flag == DB_VAR_SET && vp->precious)
	261	db_read_write_variable(vp, &old_value, DB_VAR_GET, ap);
	262	if (func == FCN_NULL) {
	263	if (rw_flag == DB_VAR_SET)
	264	vp->valuep[(ap->level)? (ap->suffix[0] - vp->low): 0] = *valuep;
	265	else
	266	*valuep = vp->valuep[(ap->level)? (ap->suffix[0] - vp->low): 0];
	267	} else
	268	(*func)(vp, valuep, rw_flag, ap);
	269	if (rw_flag == DB_VAR_SET && vp->precious)
55e303ae	270	db_printf("\t$%s:%s<%#x>\t%#8lln\t=\t%#8lln\n", vp->name,
91447636	271	ap->modif, ap->thr_act, (unsigned long long)old_value, (unsigned long long)*valuep);
1c79356b A	272	}
	273
	274	void
	275	db_list_variable(void)
	276	{
	277	register struct db_variable *new;
	278	register struct db_variable *old;
	279	register struct db_variable *cur;
	280	unsigned int l;
	281	unsigned int len;
	282	short i;
	283	unsigned int j;
	284
	285	len = 1;
	286	for (cur = db_vars; cur < db_evars; cur++) {
	287	if (cur->min_level > 0 \|\| cur->max_level > 0) {
	288	j = 3 * (cur->max_level - cur->min_level + 1) - 1;
	289	if (cur->max_level > cur->min_level)
	290	j += 2;
	291	} else
	292	j = 0;
	293	if ((l = strlen(cur->name) + j) >= len)
	294	len = l + 1;
	295	}
	296
	297	old = (struct db_variable *)0;
	298	for (;;) {
	299	new = (struct db_variable *)0;
	300	for (cur = db_vars; cur < db_evars; cur++)
	301	if ((new == (struct db_variable *)0 \|\|
	302	strcmp(cur->name, new->name) < 0) &&
	303	(old == (struct db_variable *)0 \|\|
	304	strcmp(cur->name, old->name) > 0))
	305	new = cur;
	306	if (new == (struct db_variable *)0)
	307	return;
	308	db_reserve_output_position(len);
	309	db_printf(new->name);
	310	j = strlen(new->name);
	311	if (new->min_level > 0) {
	312	db_putchar('?');
	313	db_putchar('?');
	314	j += 2;
	315	for (i = new->min_level - 1; i > 0; i--) {
	316	db_putchar('.');
	317	db_putchar('?');
	318	db_putchar('?');
	319	j += 3;
	320	}
	321	if (new->max_level > new->min_level) {
	322	db_putchar('[');
	323	db_putchar('.');
	324	db_putchar('?');
	325	db_putchar('?');
	326	j += 4;
	327	}
	328	i = new->min_level + 1;
	329	} else {
	330	if (new->max_level > new->min_level) {
	331	db_putchar('[');
	332	j++;
	333	}
	334	i = new->min_level;
	335	}
336	while (i++ < new->max_level) {
337	db_putchar('.');
338	db_putchar('?');
339	db_putchar('?');
340	j += 3;
341	}
342	if (new->max_level > new->min_level) {
343	db_putchar(']');
344	j++;
345	}
346	while (j++ < len)
347	db_putchar(' ');
348	old = new;
349	}
350	}
351
352	void
353	db_set_cmd(void)
354	{
355	db_expr_t value;
356	int t;
357	struct db_variable *vp;
358	struct db_var_aux_param aux_param;
359	char modif[TOK_STRING_SIZE];
360
361	aux_param.modif = modif;
362	t = db_read_token();
363	if (t == tIDENT && strcmp("help", db_tok_string) == 0) {
364	db_list_variable();
365	return;
366	}
367	if (t != tDOLLAR) {
368	db_error("Variable name should be prefixed with $\n");
369	return;
370	}
371	if (!db_find_variable(&vp, &aux_param)) {
372	db_error("Unknown variable\n");
373	return;
374	}
375
376	t = db_read_token();
377	if (t != tEQ)
378	db_unread_token(t);
379
380	if (!db_expression(&value)) {
381	db_error("No value\n");
382	return;
383	}
384	if ((t = db_read_token()) == tSEMI_COLON)
385	db_unread_token(t);
386	else if (t != tEOL)
387	db_error("?\n");
388
389	db_read_write_variable(vp, &value, DB_VAR_SET, &aux_param);
390	}
391
392	void
393	db_show_one_variable(void)
394	{
395	struct db_variable *cur;
396	unsigned int len;
397	unsigned int sl;
398	unsigned int slen;
399	short h;
400	short i;
401	short j;
402	short k;
403	short low;
404	int hidden_level;
405	struct db_var_aux_param aux_param;
406	char *p;
407	char *q;
408	char *name;
409	db_addr_t offset;
410
411	for (cur = db_vars; cur < db_evars; cur++)
412	if (db_cmp_variable_name(cur, db_tok_string, &aux_param))
413	break;
414	if (cur == db_evars) {
415	for (cur = db_vars; cur < db_evars; cur++) {
416	for (q = cur->name, p = db_tok_string; q && p == *q; p++,q++)
417	continue;
418	if (*q == '\0')
419	break;
420	}
421	if (cur == db_evars) {
422	db_error("Unknown variable\n");
423	return;
424	}
425
426	for (i = 0; p && p != ':' && i < cur->max_level; i++, p = q)
427	if ((q = db_get_suffix(p, &aux_param.suffix[i])) == 0)
428	break;
429	aux_param.level = i;
430	if ((p && p != ':') \|\|
431	(i > 0 && (aux_param.suffix[0] < cur->low \|\|
432	(cur->high >= 0 &&
433	aux_param.suffix[0] > cur->high)))) {
434	db_error("Unknown variable format\n");
435	return;
436	}
437
438	strcpy(aux_param.modif, *p ? p + 1 : "");
439	aux_param.thr_act = (db_option(aux_param.modif, 't') ?
91447636	440	db_default_act : THREAD_NULL);
1c79356b A	441	}
	442
	443	if (cur->hidden_level)
	444	if (*cur->hidden_levelp >= cur->hidden_low &&
	445	*cur->hidden_levelp <= cur->hidden_high) {
	446	hidden_level = 1;
	447	aux_param.hidden_level = h = *cur->hidden_levelp;
	448	} else {
	449	hidden_level = 0;
	450	aux_param.hidden_level = h = cur->hidden_low;
	451	slen = 1;
	452	for (k = aux_param.level > 0 ? aux_param.suffix[0] : cur->high;
	453	k > 9; k /= 10)
	454	slen++;
	455	}
	456	else
	457	aux_param.hidden_level = -1;
	458
	459	if ((cur->min_level == 0 && !cur->hidden_level) \|\| cur->high < 0)
	460	j = 0;
	461	else {
	462	if (cur->min_level > 0) {
	463	j = 1;
	464	for (k = aux_param.level > 0 ?
	465	aux_param.suffix[0] : cur->high; k > 9; k /= 10)
	466	j++;
	467	} else
	468	j = 0;
	469	if (cur->hidden_level && hidden_level == 0) {
	470	j += 3;
	471	for (k = aux_param.hidden_level >= 0 ?
	472	aux_param.hidden_level : cur->hidden_high; k > 9; k /= 10)
	473	j++;
	474	}
	475	}
	476	len = strlen(cur->name) + j;
	477	i = low = aux_param.level > 0 ? aux_param.suffix[0] : cur->low;
	478
	479	for (;;) {
	480	db_printf(cur->name);
	481	j = strlen(cur->name);
	482	if (cur->high >= 0) {
	483	if (cur->min_level > 0) {
	484	db_printf("%d", i);
	485	j++;
	486	for (k = i; k > 9; k /= 10)
	487	j++;
	488	}
	489	if (cur->hidden_level && hidden_level == 0) {
	490	sl = 1;
	491	for (k = i; k > 9; k /= 10)
	492	sl++;
	493	while (sl++ < slen) {
	494	db_putchar(' ');
	495	j++;
	496	}
	497	db_printf("[%d]", h);
	498	j += 3;
	499	for (k = h; k > 9; k /= 10)
	500	j++;
	501	}
	502	}
	503
	504	while (j++ < len)
505	db_putchar(' ');
506	db_putchar(':');
507	db_putchar(' ');
508
509	if (cur->fcn) {
510	aux_param.suffix[0] = i;
511	(cur->fcn)(cur, (db_expr_t )0, DB_VAR_SHOW, &aux_param);
512	} else {
91447636	513	db_printf("%#lln", (unsigned long long)*(cur->valuep + i));
1c79356b A	514	db_find_xtrn_task_sym_and_offset(*(cur->valuep + i), &name,
	515	&offset, TASK_NULL);
	516	if (name != (char *)0 && offset <= db_maxoff &&
	517	offset != *(cur->valuep + i)) {
	518	db_printf("\t%s", name);
	519	if (offset != 0)
91447636	520	db_printf("+%#llr", (unsigned long long)offset);
1c79356b A	521	}
	522	}
	523	db_putchar('\n');
	524	if (cur->high < 0)
	525	break;
	526	if (aux_param.level > 0 \|\| i++ == cur->high) {
	527	if (!cur->hidden_level \|\|
	528	hidden_level == 0 \|\|
	529	h++ == cur->hidden_high)
	530	break;
	531	aux_param.hidden_level = h;
	532	i = low;
	533	}
	534	}
	535	}
	536
	537	void
	538	db_show_variable(void)
	539	{
	540	struct db_variable *cur;
	541	unsigned int l;
	542	unsigned int len;
	543	unsigned int sl;
	544	unsigned int slen;
	545	short h;
	546	short i;
	547	short j;
	548	short k;
	549	int t;
	550	int t1;
	551	struct db_var_aux_param aux_param;
	552	char *name;
	553	db_addr_t offset;
	554
	555	switch(t = db_read_token()) {
	556	case tEOL:
	557	case tEOF:
	558	case tSEMI_COLON:
	559	break;
	560
	561	case tDOLLAR:
	562	t1 = db_read_token();
	563	if (t1 == tIDENT) {
	564	db_show_one_variable();
	565	return;
	566	}
	567	db_error("Not a variable name after $\n");
	568	db_unread_token(t);
	569	return;
	570
	571	default:
	572	db_error("Variable name should be prefixed with $\n");
	573	db_unread_token(t);
	574	return;
	575	}
	576	db_unread_token(t);
	577
	578	slen = len = 1;
	579	for (cur = db_vars; cur < db_evars; cur++) {
	580	if ((cur->min_level == 0 && !cur->hidden_level) \|\| cur->high < 0)
	581	j = 0;
	582	else {
	583	if (cur->min_level > 0) {
	584	j = 1;
585	for (k = cur->high; k > 9; k /= 10)
586	j++;
587	} else
588	j = 0;
589	if (cur->hidden_level &&
590	(*cur->hidden_levelp < cur->hidden_low \|\|
591	*cur->hidden_levelp > cur->hidden_high)) {
592	j += 3;
593	for (k = cur->hidden_high; k > 9; k /= 10)
594	j++;
595	}
596	}
597	if ((l = strlen(cur->name) + j) >= len)
598	len = l + 1;
599	}
600
601	aux_param.modif = "";
602	aux_param.level = 1;
91447636	603	aux_param.thr_act = THREAD_NULL;
1c79356b A	604
	605	for (cur = db_vars; cur < db_evars; cur++) {
	606	i = cur->low;
	607	if (cur->hidden_level) {
	608	if (*cur->hidden_levelp >= cur->hidden_low &&
	609	*cur->hidden_levelp <= cur->hidden_high) {
	610	h = cur->hidden_low - 1;
	611	aux_param.hidden_level = *cur->hidden_levelp;
	612	} else {
	613	h = cur->hidden_low;
	614	aux_param.hidden_level = cur->hidden_low;
	615	}
	616	slen = 1;
	617	for (k = cur->high; k > 9; k /= 10)
	618	slen++;
	619	} else
	620	aux_param.hidden_level = -1;
	621
	622	if (cur != db_vars && cur->high >= 0 &&
	623	(cur->min_level > 0 \|\| cur->hidden_level))
	624	db_putchar('\n');
	625
	626	for (;;) {
	627	db_printf(cur->name);
	628	j = strlen(cur->name);
	629	if (cur->high >= 0) {
	630	if (cur->min_level > 0) {
	631	db_printf("%d", i);
	632	j++;
	633	for (k = i; k > 9; k /= 10)
	634	j++;
	635	}
	636	if (cur->hidden_level && h >= cur->hidden_low) {
	637	sl = 1;
	638	for (k = i; k > 9; k /= 10)
	639	sl++;
	640	while (sl++ < slen) {
	641	db_putchar(' ');
	642	j++;
	643	}
	644	db_printf("[%d]", h);
	645	j += 3;
	646	for (k = h; k > 9; k /= 10)
	647	j++;
	648	}
	649	}
	650	while (j++ < len)
	651	db_putchar(' ');
	652	db_putchar(':');
	653	db_putchar(' ');
	654
	655	if (cur->fcn) {
	656	aux_param.suffix[0] = i;
	657	(cur->fcn)(cur, (db_expr_t )0, DB_VAR_SHOW, &aux_param);
	658	} else {
91447636	659	db_printf("%#lln", (unsigned long long)*(cur->valuep + i));
1c79356b A	660	db_find_xtrn_task_sym_and_offset(*(cur->valuep + i), &name,
	661	&offset, TASK_NULL);
	662	if (name != (char *)0 && offset <= db_maxoff &&
	663	offset != *(cur->valuep + i)) {
	664	db_printf("\t%s", name);
	665	if (offset != 0)
91447636	666	db_printf("+%#llr", (unsigned long long)offset);
1c79356b A	667	}
	668	}
	669	db_putchar('\n');
	670	if (cur->high < 0)
	671	break;
	672	if (i++ == cur->high) {
	673	if (!cur->hidden_level \|\| h++ == cur->hidden_high)
	674	break;
	675	aux_param.hidden_level = h;
	676	i = cur->low;
	677	}
	678	}
	679	}
	680	}
	681
	682	/*
	683	* given a name of a machine register, return a variable pointer to it.
	684	*/
	685	db_variable_t
	686	db_find_reg_name(
	687	char *s)
	688	{
	689	register db_variable_t regp;
	690
	691	if ( s == (char *)0 )
	692	return DB_VAR_NULL;
	693
	694	for (regp = db_regs; regp < db_eregs; regp++) {
	695	if ( strcmp( s, regp->name) == 0 )
	696	return regp;
	697	}
	698	return DB_VAR_NULL;
	699	}