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; } }