[deliverable/binutils-gdb.git] / gdb / rdi-share / params.h

/* 
 * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
 * 
 * This software may be freely used, copied, modified, and distributed
 * provided that the above copyright notice is preserved in all copies of the
 * software.
 */

/* -*-C-*-
 *
 * $Revision$
 *     $Date$
 *
 *
 *   Project: ANGEL
 *
 *     Title: Parameter negotiation structures and utilities
 */

#ifndef angel_params_h
#define angel_params_h

#include "angel.h"
#include "adp.h"

#ifndef TARGET
# include "host.h"
#endif

/* A single parameter, with tag */
typedef struct Parameter {
      ADP_Parameter     type;
      unsigned int      value;
} Parameter;

/* A list of parameter values, with tag */
typedef struct ParameterList {
      ADP_Parameter     type;
      unsigned int      num_options;
      unsigned int     *option; /* points to array of values */
} ParameterList;

/* A configuration of one or more parameters */
typedef struct ParameterConfig {
      unsigned int      num_parameters;
      Parameter        *param;  /* pointer to array of Parameters */
} ParameterConfig;

/* A set of parameter options */
typedef struct ParameterOptions {
      unsigned int      num_param_lists;
      ParameterList    *param_list; /* pointer to array of ParamLists */
} ParameterOptions;

/*
 * Function: Angel_MatchParams
 *  Purpose: find a configuration from the requested options which is
 *           the best match from the supported options.
 *
 *   Params:
 *              Input: requested      The offered set of parameters.
 *                     supported      The supported set of parameters.
 *
 *            Returns: ptr to config  A match has been made, ptr to result
 *                                      will remain valid until next call to
 *                                      this function.
 *                     NULL           Match not possible
 */
const ParameterConfig *Angel_MatchParams( const ParameterOptions *requested,
                                          const ParameterOptions *supported );

/*
 * Function: Angel_FindParam
 *  Purpose: find the value of a given parameter from a config.
 *
 *   Params:
 *              Input: type     parameter type to find
 *                     config   config to search
 *             Output: value    parameter value if found
 *
 *            Returns: TRUE     parameter found
 *                     FALSE    parameter not found
 */
bool Angel_FindParam( ADP_Parameter          type,
                      const ParameterConfig *config,
                      unsigned int          *value );

/*
 * Function: Angel_StoreParam
 *  Purpose: store the value of a given parameter in a config.
 *
 *   Params:
 *             In/Out: config   config to store in
 *              Input: type     parameter type to store
 *                     value    parameter value if found
 *
 *            Returns: TRUE     parameter found and new value stored
 *                     FALSE    parameter not found
 */
bool Angel_StoreParam( ParameterConfig *config,
                       ADP_Parameter    type,
                       unsigned int     value );

/*
 * Function: Angel_FindParamList
 *  Purpose: find the parameter list of a given parameter from an options.
 *
 *   Params:
 *              Input: type     parameter type to find
 *                     options  options block to search
 *
 *            Returns: pointer to list
 *                     NULL     parameter not found
 */
ParameterList *Angel_FindParamList( const ParameterOptions *options,
                                    ADP_Parameter           type );

/*
 * Function: Angel_BuildParamConfigMessage
 *  Purpose: write a parameter config to a buffer in ADP format.
 *
 *   Params:
 *              Input: buffer   where to write to
 *                     config   the parameter config to write
 *
 *            Returns: number of characters written to buffer
 */
unsigned int Angel_BuildParamConfigMessage( unsigned char         *buffer,
                                            const ParameterConfig *config );

/*
 * Function: Angel_BuildParamOptionsMessage
 *  Purpose: write a parameter Options to a buffer in ADP format.
 *
 *   Params:
 *              Input: buffer   where to write to
 *                     options  the options block to write
 *
 *            Returns: number of characters written to buffer
 */
unsigned int Angel_BuildParamOptionsMessage( unsigned char          *buffer,
                                             const ParameterOptions *options );

/*
 * Function: Angel_ReadParamConfigMessage
 *  Purpose: read a parameter config from a buffer where it is in ADP format.
 *
 *   Params:
 *              Input: buffer   where to read from
 *             In/Out: config   the parameter config to read to, which must
 *                              be set up on entry with a valid array, and
 *                              the size of the array in num_parameters.
 *
 *            Returns: TRUE     okay
 *                     FALSE    not enough space in config
 */
bool Angel_ReadParamConfigMessage( const unsigned char *buffer,
                                   ParameterConfig     *config );

/*
 * Function: Angel_ReadParamOptionsMessage
 *  Purpose: read a parameter options from a buffer
 *             where it is in ADP format.
 *
 *   Params:
 *              Input: buffer   where to read from
 *             In/Out: options  the parameter options block to read to, 
 *                                which must be set up on entry with a valid
 *                                array, and the size of the array in
 *                                num_parameters.  Each param_list must
 *                                also be set up in the same way.
 *
 *            Returns: TRUE     okay
 *                     FALSE    not enough space in options
 */
bool Angel_ReadParamOptionsMessage( const unsigned char *buffer,
                                    ParameterOptions    *options );

#endif /* ndef angel_params_h */

/* EOF params.h */
Commit	Line	Data
c906108c SS	1	/*
	2	* Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
	3	*
	4	* This software may be freely used, copied, modified, and distributed
	5	* provided that the above copyright notice is preserved in all copies of the
	6	* software.
	7	*/
	8
	9	/* --C--
	10	*
	11	* $Revision$
	12	* $Date$
	13	*
	14	*
	15	* Project: ANGEL
	16	*
	17	* Title: Parameter negotiation structures and utilities
	18	*/
	19
	20	#ifndef angel_params_h
	21	#define angel_params_h
	22
	23	#include "angel.h"
	24	#include "adp.h"
	25
	26	#ifndef TARGET
	27	# include "host.h"
	28	#endif
	29
	30	/* A single parameter, with tag */
	31	typedef struct Parameter {
	32	ADP_Parameter type;
	33	unsigned int value;
	34	} Parameter;
	35
	36	/* A list of parameter values, with tag */
	37	typedef struct ParameterList {
	38	ADP_Parameter type;
	39	unsigned int num_options;
	40	unsigned int option; / points to array of values */
	41	} ParameterList;
	42
	43	/* A configuration of one or more parameters */
	44	typedef struct ParameterConfig {
	45	unsigned int num_parameters;
	46	Parameter param; / pointer to array of Parameters */
	47	} ParameterConfig;
	48
	49	/* A set of parameter options */
	50	typedef struct ParameterOptions {
	51	unsigned int num_param_lists;
	52	ParameterList param_list; / pointer to array of ParamLists */
	53	} ParameterOptions;
	54
	55	/*
	56	* Function: Angel_MatchParams
	57	* Purpose: find a configuration from the requested options which is
	58	* the best match from the supported options.
	59	*
	60	* Params:
	61	* Input: requested The offered set of parameters.
	62	* supported The supported set of parameters.
	63	*
	64	* Returns: ptr to config A match has been made, ptr to result
65	* will remain valid until next call to
66	* this function.
67	* NULL Match not possible
68	*/
69	const ParameterConfig Angel_MatchParams( const ParameterOptions requested,
70	const ParameterOptions *supported );
71
72	/*
73	* Function: Angel_FindParam
74	* Purpose: find the value of a given parameter from a config.
75	*
76	* Params:
77	* Input: type parameter type to find
78	* config config to search
79	* Output: value parameter value if found
80	*
81	* Returns: TRUE parameter found
82	* FALSE parameter not found
83	*/
84	bool Angel_FindParam( ADP_Parameter type,
85	const ParameterConfig *config,
86	unsigned int *value );
87
88	/*
89	* Function: Angel_StoreParam
90	* Purpose: store the value of a given parameter in a config.
91	*
92	* Params:
93	* In/Out: config config to store in
94	* Input: type parameter type to store
95	* value parameter value if found
96	*
97	* Returns: TRUE parameter found and new value stored
98	* FALSE parameter not found
99	*/
100	bool Angel_StoreParam( ParameterConfig *config,
101	ADP_Parameter type,
102	unsigned int value );
103
104	/*
105	* Function: Angel_FindParamList
106	* Purpose: find the parameter list of a given parameter from an options.
107	*
108	* Params:
109	* Input: type parameter type to find
110	* options options block to search
111	*
112	* Returns: pointer to list
113	* NULL parameter not found
114	*/
115	ParameterList Angel_FindParamList( const ParameterOptions options,
116	ADP_Parameter type );
117
118	/*
119	* Function: Angel_BuildParamConfigMessage
120	* Purpose: write a parameter config to a buffer in ADP format.
121	*
122	* Params:
123	* Input: buffer where to write to
124	* config the parameter config to write
125	*
126	* Returns: number of characters written to buffer
127	*/
128	unsigned int Angel_BuildParamConfigMessage( unsigned char *buffer,
129	const ParameterConfig *config );
130
131	/*
132	* Function: Angel_BuildParamOptionsMessage
133	* Purpose: write a parameter Options to a buffer in ADP format.
134	*
135	* Params:
136	* Input: buffer where to write to
137	* options the options block to write
138	*
139	* Returns: number of characters written to buffer
140	*/
141	unsigned int Angel_BuildParamOptionsMessage( unsigned char *buffer,
142	const ParameterOptions *options );
143
144	/*
145	* Function: Angel_ReadParamConfigMessage
146	* Purpose: read a parameter config from a buffer where it is in ADP format.
147	*
148	* Params:
149	* Input: buffer where to read from
150	* In/Out: config the parameter config to read to, which must
151	* be set up on entry with a valid array, and
152	* the size of the array in num_parameters.
153	*
154	* Returns: TRUE okay
155	* FALSE not enough space in config
156	*/
157	bool Angel_ReadParamConfigMessage( const unsigned char *buffer,
158	ParameterConfig *config );
159
160	/*
161	* Function: Angel_ReadParamOptionsMessage
162	* Purpose: read a parameter options from a buffer
163	* where it is in ADP format.
164	*
165	* Params:
166	* Input: buffer where to read from
167	* In/Out: options the parameter options block to read to,
168	* which must be set up on entry with a valid
169	* array, and the size of the array in
170	* num_parameters. Each param_list must
171	* also be set up in the same way.
172	*
173	* Returns: TRUE okay
174	* FALSE not enough space in options
175	*/
176	bool Angel_ReadParamOptionsMessage( const unsigned char *buffer,
177	ParameterOptions *options );
178
179	#endif /* ndef angel_params_h */
180
181	/* EOF params.h */