int set_Glyph(struct Parse_state *state, void *glyphAddress_void,
void *glyphmodule_void)
{
int return_code;
cmzn_glyph **glyphAddress = reinterpret_cast<cmzn_glyph **>(glyphAddress_void);
cmzn_glyphmodule *glyphmodule = reinterpret_cast<cmzn_glyphmodule *>(glyphmodule_void);
if (state && glyphAddress && glyphmodule)
{
const char *current_token = state->current_token;
if (current_token)
{
if (!Parse_state_help_mode(state))
{
if (fuzzy_string_compare(current_token, "NONE"))
{
if (*glyphAddress)
{
cmzn_glyph_destroy(glyphAddress);
}
return_code=1;
}
else
{
cmzn_glyph *glyph = cmzn_glyphmodule_find_glyph_by_name(glyphmodule, current_token);
if (glyph)
{
if (*glyphAddress)
{
cmzn_glyph_destroy(glyphAddress);
}
*glyphAddress = glyph;
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE, "Unknown glyph : %s", current_token);
return_code = 0;
}
}
shift_Parse_state(state, 1);
}
else
{
display_message(INFORMATION_MESSAGE," GLYPH_NAME|none");
/* if possible, then write the name */
cmzn_glyph *glyph = *glyphAddress;
if (glyph)
{
display_message(INFORMATION_MESSAGE, "[%s]", glyph->getName());
}
else
{
display_message(INFORMATION_MESSAGE, "[none]");
}
return_code = 1;
}
}
else
{
display_message(WARNING_MESSAGE, "Missing glyph name");
display_parse_state_location(state);
return_code = 0;
}
}
else
{
display_message(ERROR_MESSAGE, "set_Glyph. Invalid argument(s)");
return_code = 0;
}
return (return_code);
}
int define_Computed_field_type_matrix_multiply(struct Parse_state *state,
void *field_modify_void,void *computed_field_matrix_operators_package_void)
/*******************************************************************************
LAST MODIFIED : 25 August 2006
DESCRIPTION :
Converts <field> into type COMPUTED_FIELD_MATRIX_MULTIPLY (if it is not
already) and allows its contents to be modified.
==============================================================================*/
{
const char *current_token;
int i, number_of_rows, return_code;
struct Computed_field **source_fields;
Computed_field_modify_data *field_modify;
struct Option_table *option_table;
struct Set_Computed_field_array_data set_field_array_data;
struct Set_Computed_field_conditional_data set_field_data;
ENTER(define_Computed_field_type_matrix_multiply);
USE_PARAMETER(computed_field_matrix_operators_package_void);
if (state&&(field_modify=(Computed_field_modify_data *)field_modify_void))
{
return_code=1;
if (ALLOCATE(source_fields,struct Computed_field *,2))
{
/* get valid parameters for matrix_multiply field */
number_of_rows = 1;
source_fields[0] = (struct Computed_field *)NULL;
source_fields[1] = (struct Computed_field *)NULL;
if ((NULL != field_modify->get_field()) &&
(computed_field_matrix_multiply_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code=Computed_field_get_type_matrix_multiply(field_modify->get_field(),
&number_of_rows,&(source_fields[0]),&(source_fields[1]));
}
if (return_code)
{
/* ACCESS the source fields for set_Computed_field_array */
for (i=0;i<2;i++)
{
if (source_fields[i])
{
ACCESS(Computed_field)(source_fields[i]);
}
}
/* try to handle help first */
current_token=state->current_token;
if (current_token != 0)
{
if (!(strcmp(PARSER_HELP_STRING,current_token)&&
strcmp(PARSER_RECURSIVE_HELP_STRING,current_token)))
{
option_table = CREATE(Option_table)();
Option_table_add_help(option_table,
"A matrix_mutliply field calculates the product of two matrices, giving a new m by n matrix. The product is represented as a field with a list of (m * n) components. The components of the matrix are listed row by row. The <number_of_rows> m is used to infer the dimensions of the source matrices. The two source <fields> are multiplied, with the components of the first interpreted as a matrix with dimensions m by s and the second as a matrix with dimensions s by n. If the matrix dimensions are not consistent then an error is returned. See a/curvature for an example of using the matrix_multiply field.");
Option_table_add_entry(option_table,"number_of_rows",
&number_of_rows,NULL,set_int_positive);
set_field_data.conditional_function=
Computed_field_has_numerical_components;
set_field_data.conditional_function_user_data=(void *)NULL;
set_field_data.computed_field_manager=
field_modify->get_field_manager();
set_field_array_data.number_of_fields=2;
set_field_array_data.conditional_data= &set_field_data;
Option_table_add_entry(option_table,"fields",source_fields,
&set_field_array_data,set_Computed_field_array);
return_code=Option_table_multi_parse(option_table,state);
DESTROY(Option_table)(&option_table);
}
else
{
/* if the "number_of_rows" token is next, read it */
if (fuzzy_string_compare(current_token,"number_of_rows"))
{
option_table = CREATE(Option_table)();
/* number_of_rows */
Option_table_add_entry(option_table,"number_of_rows",
&number_of_rows,NULL,set_int_positive);
return_code = Option_table_parse(option_table,state);
DESTROY(Option_table)(&option_table);
}
if (return_code)
{
option_table = CREATE(Option_table)();
set_field_data.conditional_function=
Computed_field_has_numerical_components;
set_field_data.conditional_function_user_data=(void *)NULL;
set_field_data.computed_field_manager=
field_modify->get_field_manager();
set_field_array_data.number_of_fields=2;
set_field_array_data.conditional_data= &set_field_data;
Option_table_add_entry(option_table,"fields",source_fields,
&set_field_array_data,set_Computed_field_array);
return_code = Option_table_multi_parse(option_table, state);
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
cmzn_fieldmodule_create_field_matrix_multiply(field_modify->get_field_module(),
number_of_rows, source_fields[0], source_fields[1]));
}
DESTROY(Option_table)(&option_table);
}
if (!return_code)
{
/* error */
display_message(ERROR_MESSAGE,
"define_Computed_field_type_matrix_multiply. Failed");
}
}
}
else
{
display_message(ERROR_MESSAGE, "Missing command options");
return_code = 0;
}
for (i=0;i<2;i++)
{
if (source_fields[i])
{
DEACCESS(Computed_field)(&(source_fields[i]));
}
}
}
DEALLOCATE(source_fields);
}
else
{
int set_Spectrum(struct Parse_state *state,void *spectrum_address_void,
void *spectrum_manager_void)
/*******************************************************************************
LAST MODIFIED : 22 June 1999
DESCRIPTION :
A modifier function to set the spectrum by finding in the spectrum manager
the name given in the next token of the parser
==============================================================================*/
{
const char *current_token;
int return_code;
struct Spectrum *temp_spectrum,**spectrum_address;
struct MANAGER(Spectrum) *spectrum_manager;
ENTER(set_Spectrum);
if (state)
{
current_token=state->current_token;
if (current_token)
{
if (strcmp(PARSER_HELP_STRING,current_token)&&
strcmp(PARSER_RECURSIVE_HELP_STRING,current_token))
{
spectrum_address=(struct Spectrum **)spectrum_address_void;
spectrum_manager=(struct MANAGER(Spectrum) *)spectrum_manager_void;
if (spectrum_address && spectrum_manager)
{
if (fuzzy_string_compare(current_token,"NONE"))
{
if (*spectrum_address)
{
DEACCESS(Spectrum)(spectrum_address);
*spectrum_address=(struct Spectrum *)NULL;
}
return_code=1;
}
else
{
temp_spectrum=FIND_BY_IDENTIFIER_IN_MANAGER(Spectrum, name)(current_token,spectrum_manager);
if (temp_spectrum)
{
if (*spectrum_address!=temp_spectrum)
{
DEACCESS(Spectrum)(spectrum_address);
*spectrum_address=ACCESS(Spectrum)(temp_spectrum);
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,"Unknown spectrum : %s",
current_token);
return_code=0;
}
}
shift_Parse_state(state,1);
}
else
{
display_message(ERROR_MESSAGE,
"set_Spectrum. Invalid argument(s). spectrum_address %p. spectrum_manager %p",
spectrum_address_void,spectrum_manager_void);
return_code=0;
}
}
else
{
display_message(INFORMATION_MESSAGE," SPECTRUM_NAME|none");
/* if possible, then write the name */
spectrum_address = (struct Spectrum **)spectrum_address_void;
if (spectrum_address)
{
temp_spectrum = *spectrum_address;
if (temp_spectrum)
{
display_message(INFORMATION_MESSAGE,"[%s]",temp_spectrum->name);
}
else
{
display_message(INFORMATION_MESSAGE,"[none]");
}
}
return_code=1;
}
}
