/* * Copyright (C) 1998 by Southwest Research Institute (SwRI) * * All rights reserved under U.S. Copyright Law and International Conventions. * * The development of this Software was supported by contracts NAG5-3148, * NAG5-6855, NAS8-36840, NAG5-2323, and NAG5-7043 issued on behalf of * the United States Government by its National Aeronautics and Space * Administration. Southwest Research Institute grants to the Government, * and others acting on its behalf, a paid-up nonexclusive, irrevocable, * worldwide license to reproduce, prepare derivative works, and perform * publicly and display publicly, by or on behalf of the Government. * Other than those rights granted to the United States Government, no part * of this Software may be reproduced in any form or by any means, electronic * or mechanical, including photocopying, without permission in writing from * Southwest Research Institute. All inquiries should be addressed to: * * Director of Contracts * Southwest Research Institute * P. O. Drawer 28510 * San Antonio, Texas 78228-0510 * * * Use of this Software is governed by the terms of the end user license * agreement, if any, which accompanies or is included with the Software * (the "License Agreement"). An end user will be unable to install any * Software that is accompanied by or includes a License Agreement, unless * the end user first agrees to the terms of the License Agreement. Except * as set forth in the applicable License Agreement, any further copying, * reproduction or distribution of this Software is expressly prohibited. * Installation assistance, product support and maintenance, if any, of the * Software is available from SwRI and/or the Third Party Providers, as the * case may be. * * Disclaimer of Warranty * * SOFTWARE IS WARRANTED, IF AT ALL, IN ACCORDANCE WITH THESE TERMS OF THE * LICENSE AGREEMENT. UNLESS OTHERWISE EXPLICITLY STATED, THIS SOFTWARE IS * PROVIDED "AS IS", IS EXPERIMENTAL, AND IS FOR NON-COMMERCIAL USE ONLY, * AND ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR * PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED, EXCEPT TO THE EXTENT THAT * SUCH DISCLAIMERS ARE HELD TO BE LEGALLY INVALID. * * Limitation of Liability * * SwRI SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED AS A RESULT OF USING, * MODIFYING, CONTRIBUTING, COPYING, DISTRIBUTING, OR DOWNLOADING THIS * SOFTWARE. IN NO EVENT SHALL SwRI BE LIABLE FOR ANY INDIRECT, PUNITIVE, * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGE (INCLUDING LOSS OF BUSINESS, * REVENUE, PROFITS, USE, DATA OR OTHER ECONOMIC ADVANTAGE) HOWEVER IT ARISES, * WHETHER FOR BREACH OF IN TORT, EVEN IF SwRI HAS BEEN PREVIOUSLY ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. YOU HAVE SOLE RESPONSIBILITY FOR ADEQUATE * PROTECTION AND BACKUP OF DATA AND/OR EQUIPMENT USED IN CONNECTION WITH THE * SOFTWARE AND WILL NOT MAKE A CLAIM AGAINST SwRI FOR LOST DATA, RE-RUN TIME, * INACCURATE OUTPUT, WORK DELAYS OR LOST PROFITS RESULTING FROM THE USE OF * THIS SOFTWARE. YOU AGREE TO HOLD SwRI HARMLESS FROM, AND YOU COVENANT NOT * TO SUE SwRI FOR, ANY CLAIMS BASED ON USING THE SOFTWARE. * * Local Laws: Export Control * * You acknowledge and agree this Software is subject to the U.S. Export * Administration Laws and Regulations. Diversion of such Software contrary * to U.S. law is prohibited. You agree that none of the Software, nor any * direct product therefrom, is being or will be acquired for, shipped, * transferred, or reexported, directly or indirectly, to proscribed or * embargoed countries or their nationals, nor be used for nuclear activities, * chemical biological weapons, or missile projects unless authorized by U.S. * Government. Proscribed countries are set forth in the U.S. Export * Administration Regulations. Countries subject to U.S embargo are: Cuba, * Iran, Iraq, Libya, North Korea, Syria, and the Sudan. This list is subject * to change without further notice from SwRI, and you must comply with the * list as it exists in fact. You certify that you are not on the U.S. * Department of Commerce's Denied Persons List or affiliated lists or on the * U.S. Department of Treasury's Specially Designated Nationals List. You agree * to comply strictly with all U.S. export laws and assume sole responsibilities * for obtaining licenses to export or reexport as may be required. * * General * * These Terms represent the entire understanding relating to the use of the * Software and prevail over any prior or contemporaneous, conflicting or * additional, communications. SwRI can revise these Terms at any time * without notice by updating this posting. * * Trademarks * * The SwRI logo is a trademark of SwRI in the United States and other countries. * */ #ident "@(#) $Id: libbase_err_msg.c 22023 2012-12-06 22:46:37Z carrie $ SwRI" #include #include #include "ret_codes.h" #include "libbase_idfs.h" /***************************************************************************** * * * LIBBASE_IDFS_ERROR_MESSAGE_STR SUBROUTINE * * * * DESCRIPTION * * This routine is called to compose the error string encountered from * * the libbase_idfs generic utility software. * * * * INPUT VARIABLES * * SDDAS_SHORT error_code the error code to be processed * * SDDAS_CHAR *e_str ptr to area where string is to be returned * * * * USAGE * * libbase_idfs_error_message_str (error_code, e_str) * * * * NECESSARY SUBPROGRAMS * * sprintf() creates a string based upon arguments and * * conversion characters * * strcpy() copies a string to another string variable * * * * EXTERNAL VARIABLES * * struct general_info structure holding information concerning * * ginfo the experiment that is being processed * * * * INTERNAL VARIABLES * * struct experiment_info a pointer to the structure that holds * * *ex specific experiment information * * * * SUBSYSTEM * * Display Level * * * *****************************************************************************/ void libbase_idfs_error_message_str (SDDAS_SHORT error_code, SDDAS_CHAR *e_str) { extern struct general_info ginfo; struct experiment_info *ex; switch (error_code) { case LOCATE_NOT_FOUND: strcpy (e_str, "IR_LOCATE_EX: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case LOCATE_PTR_MALLOC: strcpy (e_str, "IR_LOCATE_EX: NO MEMORY FOR PTR_REC INFO."); break; case LOCATE_EX_REALLOC: strcpy (e_str, "IR_LOCATE_EX: NO MEMORY FOR EX_INFO EXPANSION."); break; case OPEN_PTR_MALLOC: strcpy (e_str, "IR_FILE_SETUP: NO MEMORY FOR PTR_REC INFO."); break; case OPEN_EX_REALLOC: strcpy (e_str, "IR_FILE_SETUP: NO MEMORY FOR EX_INFO EXPANSION."); break; case ALL_FLAG_MALLOC: strcpy (e_str, "IR_FILE_SETUP: NO MEMORY FOR SENSOR FLAGS."); break; case RTIME_NO_HEADER: ex = ginfo.expt; sprintf (e_str, "IR_REALTIME_DATA_FILES: ERROR OPENING THE HEADER FILE %s.", ex->header_name); break; case RTIME_NO_DATA: ex = ginfo.expt; sprintf (e_str, "IR_REALTIME_DATA_FILES: ERROR OPENING THE DATA FILE %s.", ex->data_name); break; case ALLOC_HDR_READ_ERROR: strcpy (e_str, "IR_ALLOC_EXP_ONCE: READ ERROR ON HEADER FILE."); break; case ALLOC_HDR_MALLOC: strcpy (e_str, "IR_ALLOC_EXP_ONCE: NO MEMORY FOR HEADER INFORMATION."); break; case ALLOC_HDR_REALLOC: strcpy (e_str, "IR_ALLOC_EXP_ONCE: NO MEMORY FOR EXPANSION OF HEADER INFORMATION."); break; case SWEEP_TIME_MALLOC: strcpy (e_str, "IR_ALLOC_EXP_ONCE: NO MEMORY FOR TIME OF SAMPLE VALUES."); break; case TIME_OFF_MALLOC: strcpy (e_str, "IR_ALLOC_EXP_ONCE: NO MEMORY FOR SENSOR TIME OFFSET VALUES."); break; case EXP_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_ALLOC_EXP_ONCE: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case EXP_IDF_MANY_BYTES: strcpy (e_str, "IR_ALLOC_EXP_ONCE: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case EXP_IDF_TBL_NUM: strcpy (e_str, "IR_ALLOC_EXP_ONCE: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case EXP_IDF_CON_NUM: strcpy (e_str, "IR_ALLOC_EXP_ONCE: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case EXP_IDF_NO_ENTRY: strcpy (e_str, "IR_ALLOC_EXP_ONCE: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case PARTIAL_READ: strcpy (e_str, "THE NO. OF BYTES READ DID NOT MATCH THE NUMBER OF BYTES REQUESTED FOR HEADER OR DATA FILE."); break; case SEL_SEN_NOT_FOUND: strcpy (e_str, "SELECT_SENSOR: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case SCOM_TBL_MALLOC: strcpy (e_str, "IR_SENSOR_COMBO: NO MEMORY FOR TABLE OFFSET VALUES."); break; case SCOM_INDEX_MALLOC: strcpy (e_str, "IR_SENSOR_COMBO: NO MEMORY FOR COMBINATION INDEX VALUES FOR THE SENSORS."); break; case SCOM_SEN_PTR_MALLOC: strcpy (e_str, "IR_SENSOR_COMBO: NO MEMORY FOR SENSOR COMBINATION STRUCTURES."); break; case SCOM_PTR_MALLOC: strcpy (e_str, "IR_SENSOR_COMBO: NO MEMORY FOR ARRAY OF POINTERS TO THE TABLE OFFSET VALUES."); break; case BAD_SCPOT_FORMAT: strcpy (e_str, "IR_GET_POTENTIAL_INFO: THE FORMAT SPECIFICATION FOR THE SPACECRAFT POTENTIAL DATA IS INVALID."); break; case POT_INFO_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_POTENTIAL_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case POT_INFO_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_POTENTIAL_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case POT_INFO_IDF_TBL_NUM: strcpy (e_str, "IR_GET_POTENTIAL_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case POT_INFO_IDF_CON_NUM: strcpy (e_str, "IR_GET_POTENTIAL_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case POT_INFO_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_POTENTIAL_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case POT_BAD_SRC: strcpy (e_str, "IR_GET_POTENTIAL_INFO: THE SPACECRAFT POTENTIAL DATA SOURCE IS NON-SCALAR."); break; case CCOM_MATCH_MALLOC: strcpy (e_str, "IR_COUNT_COMBO: NO MEMORY FOR THE NO_MATCH ARRAY."); break; case CCOM_VAL_MALLOC: strcpy (e_str, "IR_COUNT_COMBO: NO MEMORY FOR THE TABLE OFFSET VALUES BEING COMPARED."); break; case CONV_MODE_MISMATCH: strcpy (e_str, "IR_CONVERT_MODE_DATA: ONLY TABLES THAT APPLY TO RAW OR PROCESSED MODE DATA IS VALID."); break; case CONV_MODE_BAD_TBL_NUM: strcpy (e_str, "IR_CONVERT_MODE_DATA: TABLE NUMBER NOT FOUND AMONGST TABLES DEFINED FOR THE MODE IN QUESTION."); break; case CONV_MODE_BAD_MODE: strcpy (e_str, "IR_CONVERT_MODE_DATA: INVALID MODE NUMBER."); break; case GET_ACTION_MALLOC: strcpy (e_str, "IR_GET_CRITICAL_INFO: NO MEMORY FOR CRITICAL STATUS ACTION ARRAY."); break; case CRIT_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_CRITICAL_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case CRIT_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_CRITICAL_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case CRIT_IDF_TBL_NUM: strcpy (e_str, "IR_GET_CRITICAL_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case CRIT_IDF_CON_NUM: strcpy (e_str, "IR_GET_CRITICAL_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case CRIT_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_CRITICAL_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case POS_NOT_FOUND: strcpy (e_str, "FILE_POS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FILE_POS_INVALID_DATA: strcpy (e_str, "FILE_POS: THE DATA STRUCTURE PASSED AS AN ARGUMENT IS NOT A VALID DATA STRUCTURE TO USE - MAY HAVE BEEN PREVIOUSLY FREED."); break; case FILE_POS_MODE: strcpy (e_str, "FILE_POS: ERROR PROCESSING MODE DEPENDENT INFORMATION."); break; case FILE_POS_PA: strcpy (e_str, "FILE_POS: ERROR PROCESSING PITCH ANGLE INFORMATION."); break; case FILE_POS_SPIN: strcpy (e_str, "FILE_POS: ERROR PROCESSING START OF SPIN DATA SOURCE INFORMATION."); break; case FILE_POS_POT: strcpy (e_str, "FILE_POS: ERROR PROCESSING SPACECRAFT POTENTIAL INFORMATION."); break; case FILE_POS_EULER: strcpy (e_str, "FILE_POS: ERROR PROCESSING EULER ANGLE INFORMATION."); break; case FILE_POS_CP: strcpy (e_str, "FILE_POS: ERROR PROCESSING CELESTIAL POSITION INFORMATION."); break; case FILE_POS_BKGD: strcpy (e_str, "FILE_POS: ERROR PROCESSING BACKGROUND INFORMATION."); break; case FILE_POS_DATA_GAP: strcpy (e_str, "FILE_POS: THE TIME RANGE REQUESTED LIES WITHIN A GAP FOUND WITHIN THE DATA FILE."); break; case POS_DATA_READ_ERROR: strcpy (e_str, "FILE_POS: READ ERROR ON DATA FILE."); break; case POS_HDR_READ_ERROR: strcpy (e_str, "FILE_POS: READ ERROR ON HEADER FILE."); break; case POS_HDR_MALLOC: strcpy (e_str, "FILE_POS: NO MEMORY FOR HEADER INFORMATION."); break; case POS_HDR_REALLOC: strcpy (e_str, "FILE_POS: NO MEMORY FOR EXPANSION OF HEADER INFORMATION."); break; case PBACK_LOS: strcpy (e_str, "FILE_POS : An LOS indicator record was encountered while trying to find the start time record."); break; case PBACK_NEXT_FILE: strcpy (e_str, "FILE_POS : A NEXT_FILE indicator record was encountered while trying to find the start time record."); break; case RHDR_READ_ERROR: strcpy (e_str, "IR_READ_HEADER: READ ERROR ON HEADER FILE."); break; case RHDR_HDR_MALLOC: strcpy (e_str, "IR_READ_HEADER: NO MEMORY FOR HEADER INFORMATION."); break; case RHDR_HDR_REALLOC: strcpy (e_str, "IR_READ_HEADER: NO MEMORY FOR EXPANSION OF HEADER INFORMATION."); break; case FILL_HEADER: strcpy (e_str, "IR_READ_HEADER: BAD HEADER RECORD READ FROM FILE - RE-RETRIEVE HEADER FILE FROM DATABASE."); break; case CONV_CAL_VECTOR_MISMATCH: strcpy (e_str, "IR_CONVERT_CAL_DATA: THE CALIBRATION DATA USES A TABLE THAT IS NOT DIMENSIONED THE SAME SIZE."); break; case CONV_CAL_MALLOC: strcpy (e_str, "IR_CONVERT_CAL_DATA: MALLOC ERROR FOR TEMPORARY DATA ARRAY."); break; case TENSOR_READ_ERROR: strcpy (e_str, "IR_NEW_DATA_RECORD: READ ERROR ON DATA FILE FOR TENSOR DATA."); break; case DREC_READ_ERROR: strcpy (e_str, "IR_NEW_DATA_RECORD: READ ERROR ON DATA FILE."); break; case DREC_HDR_READ_ERROR: strcpy (e_str, "IR_NEW_HEADER_RECORD: READ ERROR ON HEADER FILE."); break; case DREC_HDR_MALLOC: strcpy (e_str, "IR_NEW_HEADER_RECORD: NO MEMORY FOR HEADER INFORMATION."); break; case DREC_HDR_REALLOC: strcpy (e_str, "IR_NEW_HEADER_RECORD: NO MEMORY FOR EXPANSION OF HEADER INFORMATION."); break; case TENSOR_HDR_READ_ERROR: strcpy (e_str, "IR_NEW_HEADER_RECORD: READ ERROR ON HEADER FILE FOR TENSOR DATA."); break; case TENSOR_HDR_MALLOC: strcpy (e_str, "IR_NEW_HEADER_RECORD: NO MEMORY FOR HEADER INFORMATION FOR TENSOR DATA."); break; case TENSOR_HDR_REALLOC: strcpy (e_str, "IR_NEW_HEADER_RECORD: NO MEMORY FOR EXPANSION OF HEADER INFORMATION FOR TENSOR DATA."); break; case WRONG_HEADER_FORMAT: strcpy (e_str, "THERE IS A MIX-UP BETWEEN ACCESSING TENSOR AND NON-TENSOR IDFS DATA."); break; case WRONG_DATA_STRUCTURE: strcpy (e_str, "THERE IS A MIX-UP BETWEEN ACCESSING TENSOR AND NON-TENSOR IDFS DATA STRUCTURES."); break; case RESET_DATA_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR DATA ARRAY."); break; case RESET_DATA_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF DATA ARRAY."); break; case RESET_ANGLE_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF AZIMUTHAL ANGLE ARRAY."); break; case RESET_PITCH_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR PITCH ANGLE ARRAY."); break; case RESET_DCOS_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR DIRECTION COSINE STRUCTURE."); break; case RESET_DCOS_VAL_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR DIRECTION COSINE VALUES."); break; case RESET_PITCH_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF PITCH ANGLE ARRAY."); break; case RESET_DCOS_VAL_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF DIRECTION COSINE VALUES."); break; case RESET_POT_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF SPACECRAFT POTENTIAL ARRAY."); break; case RESET_TINFO_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR COORDINATE TRANSFORMATION STRUCTURE."); break; case RESET_EULER_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF EULER ANGLE ARRAY."); break; case RESET_CP_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF CELESTIAL POSITION ANGLE ARRAY."); break; case RESET_MODE_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF MODE INFORMATION."); break; case RESET_CSET_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR CAL. SET SIZE ARRAY."); break; case RESET_BKGD_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_HEADER: NO MEMORY FOR EXPANSION OF BACKGROUND ARRAY."); break; case RESET_NOT_FOUND: strcpy (e_str, "RESET_EXPERIMENT_INFO: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case ALLOC_EV_REALLOC: strcpy (e_str, "IR_ALLOC_SWP_DATA: NO MEMORY FOR EXPANSION OF EV ARRAY."); break; case CONST_ANG_MALLOC: strcpy (e_str, "IR_GET_CONSTANTS: NO MEMORY FOR ANGLE CONSTANT VALUES."); break; case CONST_TEMP_MALLOC: strcpy (e_str, "IR_GET_CONSTANTS: NO MEMORY FOR TEMPORARY WORKING SPACE."); break; case CONST_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_CONSTANTS: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case CONST_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_CONSTANTS: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case CONST_IDF_TBL_NUM: strcpy (e_str, "IR_GET_CONSTANTS: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case CONST_IDF_CON_NUM: strcpy (e_str, "IR_GET_CONSTANTS: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case CONST_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_CONSTANTS: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case TBL_MISC_MALLOC: strcpy (e_str, "IR_GET_TBL_INFO: NO MEMORY TO HOLD TABLE INFORMATION FOR ALL TELEMETRY TABLES."); break; case TBL_MALLOC: strcpy (e_str, "IR_GET_TBL_INFO: NO MEMORY TO HOLD VALUES FOR ALL TELEMETRY TABLES."); break; case TBL_VAR_NOT_CAL: strcpy (e_str, "IR_GET_TBL_INFO: FOR TBL_TYPE 2, TBL_VAR CAN ONLY BE A FN. OF CAL SETS WHEN TBL_FMT EQUALS ZERO."); break; case TBL_VAR_NOT_RAW: strcpy (e_str, "IR_GET_TBL_INFO: FOR TBL_TYPE 0, TBL_VAR CAN NOT BE PROCESSED DATA WHEN TBL_FMT EQUALS ZERO."); break; case TBL_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_TBL_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case TBL_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_TBL_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case TBL_IDF_TBL_NUM: strcpy (e_str, "IR_GET_TBL_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case TBL_IDF_CON_NUM: strcpy (e_str, "IR_GET_TBL_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case TBL_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_TBL_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case TENSOR_NOT_FOUND: strcpy (e_str, "READ_TENSOR_DATA: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case TENSOR_NO_FILES: strcpy (e_str, "READ_TENSOR_DATA: ATTEMPTED READ ON UNOPENED FILES."); break; case DREC_NOT_FOUND: strcpy (e_str, "READ_DREC: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case DREC_NO_FILES: strcpy(e_str, "READ_DREC: ATTEMPTED READ ON UNOPENED FILES."); break; case CRIT_TBL_NOT_FOUND: strcpy (e_str, "IR_CHECK_CRITICAL_STATUS: THE TABLE REQUESTED WAS NOT FOUND AMONGST SENSOR TABLES."); break; case CNVT_NOT_FOUND: strcpy (e_str, "CONVERT_TO_UNITS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case CNVT_BAD_DTYPE: strcpy (e_str, "CONVERT_TO_UNITS: THE DATA TYPE REQUESTED IS NOT SUPPORTED BY THIS ROUTINE."); break; case CNVT_BAD_TBL_NUM: strcpy (e_str, "CONVERT_TO_UNITS: INVALID TABLE NUMBER."); break; case CNVT_BAD_TBL_OPER: strcpy (e_str, "CONVERT_TO_UNITS: THERE IS NO LOOK-UP OPERATION DEFINED (OPER = 2000 or FTXX0 FOR ADVANCED BUFFER MANIPULATIONS)."); break; case CNVT_NO_TMP: strcpy (e_str, "CONVERT_TO_UNITS: NO DATA WILL BE PLACED IN INTERMEDIATE BUFFERS TO ADD TO PERMANENT BUFFERS."); break; case CNVT_TMP_MALLOC: strcpy (e_str, "CONVERT_TO_UNITS: NO MEMORY FOR THE INTERMEDIATE BUFFER SPACE."); break; case CNVT_NO_ADV: strcpy (e_str, "CONVERT_TO_UNITS: NO DATA WILL BE PLACED IN ADVANCED BUFFERS TO PERFORM COMBINATION FUNCTION ON ADVANCED BUFFERS."); break; case CNVT_BAD_BUF_NUM: strcpy (e_str, "CONVERT_TO_UNITS: COMBINATION FUNCTION ON ADVANCED BUFFERS SPECIFIES A 2 FOR THE FROM OR TO BUFFER VALUE. A VALUE OF 2 IS RESERVED AND CANNOT BE USED."); break; case CNVT_SAME_BUF_NUM: strcpy (e_str, "CONVERT_TO_UNITS: COMBINATION FUNCTION ON ADVANCED BUFFERS SPECIFIES THE SAME VALUE FOR THE FROM AND TO BUFFER VALUES."); break; case SEN_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_SENSOR_TABLES: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case SEN_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_SENSOR_TABLES: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case SEN_IDF_TBL_NUM: strcpy (e_str, "IR_GET_SENSOR_TABLES: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case SEN_IDF_CON_NUM: strcpy (e_str, "IR_GET_SENSOR_TABLES: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case SEN_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_SENSOR_TABLES: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case UPDATE_IDF_NO_FILL: strcpy (e_str, "IR_READ_IDF_UPDATE: A FILL VALUE MUST BE SPECIFIED FOR TENSOR DATA."); break; case UPDATE_IDF_BAD_PA_DEF: strcpy (e_str, "IR_READ_IDF_UPDATE: PITCH ANGLE CANNOT BE SPECIFIED FOR TENSOR DATA."); break; case UPDATE_IDF_BAD_SPIN_DEF: strcpy (e_str, "IR_READ_IDF_UPDATE: START OF SPIN DATA SOURCE CANNOT BE SPECIFIED FOR TENSOR DATA."); break; case UPDATE_IDF_BAD_POT_DEF: strcpy (e_str, "IR_READ_IDF_UPDATE: SPACECRAFT POTENTIAL DATA SOURCE CANNOT BE SPECIFIED FOR TENSOR DATA."); break; case UPDATE_IDF_BAD_PMI_DEF: strcpy (e_str, "IR_READ_IDF_UPDATE: EULER ANGLE CANNOT BE SPECIFIED FOR TENSOR DATA."); break; case UPDATE_IDF_BAD_CP_DEF: strcpy (e_str, "IR_READ_IDF_UPDATE: CELESTIAL POSITION CANNOT BE SPECIFIED FOR TENSOR DATA."); break; case UPDATE_IDF_BAD_BKGD_DEF: strcpy (e_str, "IR_READ_IDF_UPDATE: BACKGROUND CANNOT BE SPECIFIED FOR TENSOR DATA."); break; case ASCII_AFTER_SENSOR: strcpy (e_str, "IR_READ_IDF_UPDATE: ALL ASCII AND/OR MODE-DEPENDENT TABLES MUST BE DEFINED AFTER ALL OTHER TABLES."); break; case UPDATE_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_READ_IDF_UPDATE: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case UPDATE_IDF_MANY_BYTES: strcpy (e_str, "IR_READ_IDF_UPDATE: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case UPDATE_IDF_TBL_NUM: strcpy (e_str, "IR_READ_IDF_UPDATE: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case UPDATE_IDF_CON_NUM: strcpy (e_str, "IR_READ_IDF_UPDATE: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case UPDATE_IDF_NO_ENTRY: strcpy (e_str, "IR_READ_IDF_UPDATE: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case BAD_PA_FORMAT: strcpy (e_str, "IR_GET_PITCH_INFO: THE FORMAT SPECIFICATION FOR THE PITCH ANGLE DATA IS INVALID."); break; case PA_BAD_SRC: strcpy (e_str, "IR_GET_PITCH_INFO: THE PITCH ANGLE DATA SOURCE IS NON-SCALAR."); break; case PINFO_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_PITCH_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case PINFO_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_PITCH_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case PINFO_IDF_TBL_NUM: strcpy (e_str, "IR_GET_PITCH_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case PINFO_IDF_CON_NUM: strcpy (e_str, "IR_GET_PITCH_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case PINFO_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_PITCH_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case PA_TBL_MALLOC: strcpy (e_str, "IR_PITCH_ANGLE_TBL_INFO: NO MEMORY FOR TABLE APPLICATION INFORMATION."); break; case MODE_TBL_SZ_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_MODE_TBL_SIZE: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case MODE_TBL_SZ_IDF_MANY_BYTES: strcpy (e_str, "IR_MODE_TBL_SIZE: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case MODE_TBL_SZ_IDF_TBL_NUM: strcpy (e_str, "IR_MODE_TBL_SIZE: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case MODE_TBL_SZ_IDF_CON_NUM: strcpy (e_str, "IR_MODE_TBL_SIZE: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case MODE_TBL_SZ_IDF_NO_ENTRY: strcpy (e_str, "IR_MODE_TBL_SIZE: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case NEW_BAD_TBL_OFFSET: strcpy (e_str, "IR_GET_NEW_TBL: INVALID TBL_OFF VALUE ENCOUNTERED."); break; case NEW_SCALE_MALLOC: strcpy (e_str, "IR_GET_NEW_TBL: NO MEMORY FOR TABLE SCALING VALUES."); break; case NEW_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_NEW_TBL: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case NEW_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_NEW_TBL: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case NEW_IDF_TBL_NUM: strcpy (e_str, "IR_GET_NEW_TBL: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case NEW_IDF_CON_NUM: strcpy (e_str, "IR_GET_NEW_TBL: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case NEW_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_NEW_TBL: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case PBACK_NO_HEADER: ex = ginfo.expt; sprintf (e_str, "IR_PLAYBACK_DATA_FILES: ERROR OPENING THE HEADER FILE %s.", ex->header_name); break; case PBACK_NO_DATA: ex = ginfo.expt; sprintf (e_str, "IR_PLAYBACK_DATA_FILES: ERROR OPENING THE DATA FILE %s.", ex->data_name); break; case TIMING_MALLOC: strcpy (e_str, "IR_ALLOC_TIMING : NO MEMORY HAS BEEN ALLOCATED FOR PIXEL TIMING INFO."); break; case CHK_DATA_NOT_FOUND: strcpy (e_str, "IR_CHECK_IDF_DATA_MEMORY: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case NUM_CAL_REALLOC: strcpy (e_str, "IR_CHECK_CAL_SIZE: NO MEMORY FOR EXPANSION OF ARRAY THAT HOLDS RETURNED CAL. VALUES."); break; case READ_IN_BAD_TBL_OFFSET: strcpy (e_str, "IR_READ_IN_TBL: INVALID TBL_OFF VALUE ENCOUNTERED."); break; case READ_IN_MALLOC: strcpy (e_str, "IR_READ_IN_TBL: NO MEMORY FOR TABLE BEING READ IN FROM VIDF FILE."); break; case READ_IN_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_READ_IN_TBL: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case READ_IN_IDF_MANY_BYTES: strcpy (e_str, "IR_READ_IN_TBL: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case READ_IN_IDF_TBL_NUM: strcpy (e_str, "IR_READ_IN_TBL: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case READ_IN_IDF_CON_NUM: strcpy (e_str, "IR_READ_IN_TBL: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case READ_IN_IDF_NO_ENTRY: strcpy (e_str, "IR_READ_IN_TBL: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case CREATE_BAD_TBL_OFFSET: strcpy (e_str, "IR_CREATE_TBL: INVALID TBL_OFF VALUE ENCOUNTERED."); break; case CREATE_TBL_MALLOC: strcpy (e_str, "IR_CREATE_TBL: NO MEMORY FOR TABLE BEING CONSTRUCTED."); break; case CREATE_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_CREATE_TBL: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case CREATE_IDF_MANY_BYTES: strcpy (e_str, "IR_CREATE_TBL: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case CREATE_IDF_TBL_NUM: strcpy (e_str, "IR_CREATE_TBL: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case CREATE_IDF_CON_NUM: strcpy (e_str, "IR_CREATE_TBL: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case CREATE_IDF_NO_ENTRY: strcpy (e_str, "IR_CREATE_TBL: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case CALC_TRES_NOT_FOUND: strcpy (e_str, "CALC_TIME_RESOLUTION: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case IMAGE_NOT_FOUND: strcpy (e_str, "START_IMAGE: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case IMAGE_READ_ERROR: strcpy (e_str, "START_IMAGE: READ ERROR ON DATA OR HEADER FILE."); break; case IMAGE_HDR_MALLOC: strcpy (e_str, "START_IMAGE: NO MEMORY FOR HEADER INFORMATION."); break; case IMAGE_HDR_REALLOC: strcpy (e_str, "START_IMAGE: NO MEMORY FOR EXPANSION OF HEADER INFORMATION."); break; case NEXT_FILE_TIME_NOT_FOUND: strcpy (e_str, "NEXT_FILE_START_TIME: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case NEXT_FILE_TIME_FILE_OPEN: strcpy (e_str, "NEXT_FILE_START_TIME: THE USER DID NOT REQUEST MODE DATA PROCESSING WHEN FILE_OPEN WAS CALLED."); break; case NEXT_FILE_TIME_INFO_DUP: strcpy (e_str, "NEXT_FILE_START_TIME: THE EX_INFO STRUCTURE FOR THE MODE DATA HAS NEVER BEEN ALLOCATED."); break; case MODE_TBL_MISC_MALLOC: strcpy (e_str, "IR_GET_MODE_TBL: NO MEMORY TO HOLD INFORMATION FOR ALL INTEGER MODE TABLES."); break; case MODE_TBL_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_MODE_TBL: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case MODE_TBL_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_MODE_TBL: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case MODE_TBL_IDF_TBL_NUM: strcpy (e_str, "IR_GET_MODE_TBL: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case MODE_TBL_IDF_CON_NUM: strcpy (e_str, "IR_GET_MODE_TBL: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case MODE_TBL_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_MODE_TBL: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case MODE_TBL_VAR_NOT_CAL: strcpy (e_str, "IR_GET_MODE_TBL: FOR TBL_TYPE 2, TBL_VAR CAN ONLY BE A FN. OF CAL SETS WHEN TBL_FMT EQUALS ZERO."); break; case MODE_TBL_VAR_NOT_RAW: strcpy (e_str, "IR_GET_MODE_TBL: FOR TBL_TYPE 0, TBL_VAR CAN NOT BE PROCESSED DATA WHEN TBL_FMT EQUALS ZERO."); break; case MODE_TBL_MALLOC: strcpy (e_str, "IR_GET_MODE_TBL: NO MEMORY TO HOLD VALUES FOR ALL TELEMETRY TABLES."); break; case CREATE_DSTR_NOT_FOUND: strcpy (e_str, "CREATE_DATA_STRUCTURE: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case CREATE_DATA_ALL_MALLOC: strcpy (e_str, "CREATE_IDF_DATA_STRUCTURE: NO MEMORY FOR ARRAY OF POINTERS FOR IDF_DATA STRUCTURES."); break; case CREATE_DATA_ALL_REALLOC: strcpy (e_str, "CREATE_IDF_DATA_STRUCTURE: NO MEMORY FOR EXPANSION OF ARRAY OF POINTERS FOR IDF_DATA STRUCTURES."); break; case CREATE_DATA_MALLOC: strcpy (e_str, "CREATE_IDF_DATA_STRUCTURE: NO MEMORY FOR IDF_DATA STRUCTURE."); break; case PA_MAIN_DATA_MISSING: strcpy (e_str, "IR_PITCH_ANGLE_SOURCE_STATUS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case PITCH_MALLOC: strcpy (e_str, "IR_ALLOC_PITCH_INFO : NO MEMORY HAS BEEN ALLOCATED FOR PITCH ANGLE STRUCTURE."); break; case PA_UNIT_MALLOC: strcpy (e_str, "IR_ALLOC_PITCH_INFO: NO MEMORY FOR UNIT NORMAL VALUES."); break; case PA_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_PITCH_INFO: NO MEMORY FOR DATA AND NORMALIZATION VALUES."); break; case PA_BAD_FRAC: strcpy (e_str, "IR_PROCESS_PITCH_DATA: INVALID NORMALIZATION FACTOR CALCULATED FOR PITCH ANGLE DATA."); break; case PA_UNIT_NORMAL: strcpy (e_str, "IR_GET_UNIT_NORMALS: ALL THREE COMPONENTS OF THE APERTURE NORMAL VECTOR WERE NOT DEFINED."); break; case CRIT_ACT_MALLOC: strcpy (e_str, "IR_INIT_SENSOR_PTR: NO MEMORY FOR CRITICAL ACTION INFORMATION."); break; case MODE_PTR_MALLOC: strcpy (e_str, "IR_GET_MODE_INFO: NO MEMORY FOR MODE TABLE STRUCTURES."); break; case PA_BAD_TIMES: strcpy (e_str, "IR_IDFS_PITCH_ANGLES: THE END TIME OF THE SAMPLE IS LESS THAN THE START TIME."); break; case NO_PA_CONSTANT: strcpy (e_str, "IR_GET_PITCH_ANGLE_CONSTANTS: THE PITCH ANGLE CONSTANTS ARE NOT DEFINED IN THE VIDF FILE."); break; case HDR_FMT_ONE_MALLOC: strcpy (e_str, "IR_READ_HEADER_FORMAT_ONE: NO MEMORY FOR ELEMENTS PERTINENT TO ORIGINAL IDFS DEFINITION."); break; case HDR_FMT_TWO_MALLOC: strcpy (e_str, "IR_READ_HEADER_FORMAT_TWO: NO MEMORY FOR ELEMENTS PERTINENT TO TENSOR IDFS DEFINITION."); break; case HDR_FMT_TWO_DQUAL: strcpy (e_str, "IR_READ_HEADER_FORMAT_TWO: DATA QUALITY TENSOR SIZE INCONSISTENT WITH TENSOR IDFS DEFINITION."); break; case CREATE_TENSOR_DATA_ALL_MALLOC: strcpy (e_str, "CREATE_TENSOR_DATA_STRUCTURE: NO MEMORY FOR ARRAY OF POINTERS FOR TENSOR_DATA STRUCTURES."); break; case CREATE_TENSOR_DATA_ALL_REALLOC: strcpy (e_str, "CREATE_TENSOR_DATA_STRUCTURE: NO MEMORY FOR EXPANSION OF ARRAY OF POINTERS FOR TENSOR_DATA STRUCTURES."); break; case CREATE_TENSOR_DATA_MALLOC: strcpy (e_str, "CREATE_TENSOR_DATA_STRUCTURE: NO MEMORY FOR TENSOR_DATA STRUCTURE."); break; case TENSOR_MODE_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_TENSOR_HEADER: NO MEMORY FOR MODE INFORMATION."); break; case TENSOR_MODE_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_TENSOR_HEADER: NO MEMORY FOR EXPANSION OF MODE INFORMATION."); break; case TENSOR_DATA_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_TENSOR_HEADER: NO MEMORY FOR DATA ARRAY."); break; case TENSOR_DATA_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_TENSOR_HEADER: NO MEMORY FOR EXPANSION OF DATA ARRAY."); break; case TENSOR_DQUAL_MALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_TENSOR_HEADER: NO MEMORY FOR DATA QUALITY INFORMATION."); break; case TENSOR_DQUAL_REALLOC: strcpy (e_str, "IR_CHECK_DEPENDENT_ON_TENSOR_HEADER: NO MEMORY FOR EXPANSION OF DATA QUALITY INFORMATION."); break; case DKEY_PROJECT: strcpy (e_str, "GET_DATA_KEY: INVALID PROJECT NAME PASSED AS ARGUMENT."); break; case DKEY_MISSION: strcpy (e_str, "GET_DATA_KEY: INVALID MISSION NAME PASSED AS ARGUMENT."); break; case DKEY_EXPERIMENT: strcpy (e_str, "GET_DATA_KEY: INVALID EXPERIMENT NAME PASSED AS ARGUMENT."); break; case DKEY_INSTRUMENT: strcpy (e_str, "GET_DATA_KEY: INVALID INSTRUMENT NAME PASSED AS ARGUMENT."); break; case DKEY_VINST: strcpy (e_str, "GET_DATA_KEY: INVALID VIRTUAL INSTRUMENT NAME PASSED AS ARGUMENT."); break; case START_SPIN_NOT_FOUND: strcpy (e_str, "START_OF_SPIN: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case START_SPIN_NO_POS: strcpy (e_str, "START_OF_SPIN: THE ROUTINE FILE_POS HAS NOT BEEN CALLED."); break; case START_SPIN_NO_SPIN: ex = ginfo.expt; sprintf (e_str, "START_OF_SPIN: %s DOES NOT SPIN BASED UPON DATA RECORD INFO.", ex->data_name); break; case START_SPIN_ETIME: strcpy (e_str, "START_OF_SPIN: THE REQUESTED END TIME HAS BEEN REACHED BEFORE THE START OF SPIN WAS FOUND."); break; case START_SPIN_MALLOC: strcpy (e_str, "START_OF_SPIN: NO MEMORY FOR START OF SPIN INFORMATION."); break; case START_SPIN_ALL_MALLOC: strcpy (e_str, "START_OF_SPIN: NO MEMORY FOR ARRAY OF POINTERS FOR IDF_DATA STRUCTURES."); break; case TURN_OFF_PA_NOT_FOUND: strcpy (e_str, "TURN_OFF_PITCH_ANGLE_COMPUTATIONS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED.."); break; case TURN_ON_EA_NOT_FOUND: strcpy (e_str, "TURN_ON_EULER_ANGLE_COMPUTATIONS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED.."); break; case TURN_ON_CP_NOT_FOUND: strcpy (e_str, "TURN_ON_CELESTIAL_POSITION_COMPUTATIONS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED.."); break; case SPIN_SRC_BAD_SRC: strcpy (e_str, "IR_GET_SPIN_SRC_INFO: THE START OF SPIN DATA SOURCE IS NON-SCALAR."); break; case SPIN_SINFO_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_SPIN_SRC_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case SPIN_SINFO_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_SPIN_SRC_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case SPIN_SINFO_IDF_TBL_NUM: strcpy (e_str, "IR_GET_SPIN_SRC_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case SPIN_SINFO_IDF_CON_NUM: strcpy (e_str, "IR_GET_SPIN_SRC_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case SPIN_SINFO_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_SPIN_SRC_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case READ_SPIN_DSRC_READ: strcpy (e_str, "IR_READ_DREC_SPIN_SRC: ERROR READING NEXT RECORD FROM SPIN DATA SOURCE TO GET NEXT SPIN PERIOD."); break; case READ_SPIN_DSRC_BACK_SPIN: strcpy (e_str, "IR_READ_DREC_SPIN_SRC: THE NEXT SPIN PERIOD WENT BACKWARDS IN TIME."); break; case TENSOR_DATA_TDW_LEN: strcpy (e_str, "IR_FILL_TENSOR_DATA_ARRAY: ONLY BYTE-ORIENTED TENSOR DATA CAN BE DEFINED."); break; case CP_STR_MALLOC: strcpy (e_str, "IR_ALLOC_CELESTIAL_POSITION_INFO : NO MEMORY HAS BEEN ALLOCATED FOR CELESTIAL POSITION ANGLE STRUCTURE."); break; case CP_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_CELESTIAL_POSITION_INFO: NO MEMORY FOR CONSTANT / SENSOR CELESTIAL POSITION ANGLE VALUES."); break; case POT_MALLOC: strcpy (e_str, "IR_ALLOC_POTENTIAL_INFO : NO MEMORY HAS BEEN ALLOCATED FOR SPACECRAFT POTENTIAL STRUCTURE."); break; case POT_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_POTENTIAL_INFO: NO MEMORY FOR DATA AND NORMALIZATION VALUES."); break; case POT_MAIN_DATA_MISSING: strcpy (e_str, "IR_POTENTIAL_SOURCE_STATUS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case POT_TBL_MALLOC: strcpy (e_str, "IR_POTENTIAL_TBL_INFO: NO MEMORY FOR TABLE APPLICATION INFORMATION."); break; case OVERRIDE_NOT_FOUND: strcpy (e_str, "OVERRIDE_POTENTIAL_POLYNOMIAL: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case OVERRIDE_NO_POT: strcpy (e_str, "OVERRIDE_POTENTIAL_POLYNOMIAL: SPACECRAFT POTENTIAL DATA IS NOT DEFINED FOR THE SELECTED DATA SOURCE."); break; case OVERRIDE_NO_POT_TBLS: strcpy (e_str, "OVERRIDE_POTENTIAL_POLYNOMIAL: THERE ARE NO TABLES DEFINED THAT ARE A FUNCTION OF SPACECRAFT POTENTIAL DATA FOR THE SELECTED DATA SOURCE."); break; case OVERRIDE_TOO_MANY_POT_TBLS: strcpy (e_str, "OVERRIDE_POTENTIAL_POLYNOMIAL: THERE IS MORE THAN ONE TABLE DEFINED THAT IS A FUNCTION OF SPACECRAFT POTENTIAL DATA FOR THE SELECTED DATA SOURCE."); break; case OVERRIDE_TBL_FMT_MALLOC: strcpy (e_str, "OVERRIDE_POTENTIAL_POLYNOMIAL: NO MEMORY FOR THE TBL_FMT VALUES."); break; case OVERRIDE_BAD_TBL_FMT_VALUE: strcpy (e_str, "OVERRIDE_POTENTIAL_POLYNOMIAL: THE TBL_FMT VALUES DO NOT SPECIFY A FIRST ORDER POLYNOMIAL DEFINITION."); break; case POT_BAD_FRAC: strcpy (e_str, "IR_PROCESS_POTENTIAL_DATA: INVALID NORMALIZATION FACTOR CALCULATED FOR SPACECRAFT POTENTIAL DATA."); break; case EULER_MAIN_DATA_MISSING: strcpy (e_str, "IR_EULER_ANGLE_SOURCE_STATUS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case EULER_TBL_MALLOC: strcpy (e_str, "IR_EULER_ANGLE_TBL_INFO: NO MEMORY FOR TABLE APPLICATION INFORMATION."); break; case BAD_EULER_FORMAT: strcpy (e_str, "IR_GET_EULER_INFO: THE FORMAT SPECIFICATION FOR THE EULER ANGLE DATA IS INVALID."); break; case EULER_BAD_SRC: strcpy (e_str, "IR_GET_EULER_INFO: THE EULER ANGLE DATA SOURCE IS NON-SCALAR."); break; case EULER_INFO_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_EULER_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case EULER_INFO_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_EULER_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case EULER_INFO_IDF_TBL_NUM: strcpy (e_str, "IR_GET_EULER_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case EULER_INFO_IDF_CON_NUM: strcpy (e_str, "IR_GET_EULER_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case EULER_INFO_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_EULER_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case TOO_MANY_EULER: strcpy (e_str, "IR_GET_EULER_INFO: THIS DATA SET DEFINES MORE EULER ANGLES THAT THE IDFS SYSTEM CAN HANDLE."); break; case EULER_MALLOC: strcpy (e_str, "IR_ALLOC_EULER_INFO : NO MEMORY HAS BEEN ALLOCATED FOR EULER ANGLE STRUCTURE."); break; case EULER_AXIS_MALLOC: strcpy (e_str, "IR_ALLOC_EULER_INFO: NO MEMORY FOR ROTATION AXES AND CONSTANT / SENSOR VALUES."); break; case EULER_IDF_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_EULER_INFO: NO MEMORY FOR ARRAY OF POINTERS FOR IDF_DATA STRUCTURES."); break; case LESS_EULER_CONSTANT_ANGLES: strcpy (e_str, "IR_GET_EULER_ANGLE_CONSTANTS: THE NUMBER OF EULER ANGLE CONSTANTS DEFINED IN THE VIDF FILE IS LESS THAN THE NUMBER SPECIFIED WITHIN THE PMI BLOCK."); break; case LESS_EULER_CONSTANT_AXIS: strcpy (e_str, "IR_GET_EULER_ANGLE_CONSTANTS: THE NUMBER OF EULER ROTATION AXIS CONSTANTS DEFINED IN THE VIDF FILE IS LESS THAN THE NUMBER SPECIFIED WITHIN THE PMI BLOCK."); break; case MORE_EULER_CONSTANT_ANGLES: strcpy (e_str, "IR_GET_EULER_ANGLE_CONSTANTS: THE NUMBER OF EULER ANGLE CONSTANTS DEFINED IN THE VIDF FILE IS MORE THAN THE NUMBER SPECIFIED WITHIN THE PMI BLOCK."); break; case MORE_EULER_CONSTANT_AXIS: strcpy (e_str, "IR_GET_EULER_ANGLE_CONSTANTS: THE NUMBER OF EULER ROTATION AXIS CONSTANTS DEFINED IN THE VIDF FILE IS MORE THAN THE NUMBER SPECIFIED WITHIN THE PMI BLOCK."); break; case EULER_BAD_FRAC: strcpy (e_str, "IR_PROCESS_EULER_DATA: INVALID NORMALIZATION FACTOR CALCULATED FOR EULER ANGLE DATA."); break; case CP_INFO_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case CP_INFO_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case CP_INFO_IDF_TBL_NUM: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case CP_INFO_IDF_CON_NUM: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case CP_INFO_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case CP_BAD_SRC: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_INFO: THE CELESTIAL POSITION ANGLE DATA SOURCE IS NON-SCALAR."); break; case BAD_CP_FORMAT: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_INFO: THE FORMAT SPECIFICATION FOR THE CELESTIAL POSITION ANGLE DATA IS INVALID."); break; case NO_CP_CONSTANT: strcpy (e_str, "IR_GET_CELESTIAL_POSITION_CONSTANTS: THE CELESTIAL POSITION ANGLE CONSTANTS ARE NOT DEFINED IN THE VIDF FILE."); break; case VIDF_OPEN_PTR_MALLOC: strcpy (e_str, "IR_VIDF_OPEN: NO MEMORY FOR PTR_REC INFO."); break; case VIDF_OPEN_EX_REALLOC: strcpy (e_str, "IR_VIDF_OPEN: NO MEMORY FOR EX_INFO EXPANSION."); break; case CP_TBL_MALLOC: strcpy (e_str, "IR_CELESTIAL_POSITION_TBL_INFO: NO MEMORY FOR TABLE APPLICATION INFORMATION."); break; case SPIN_SRC_MALLOC: strcpy (e_str, "IR_ALLOC_SPIN_SRC_INFO: NO MEMORY FOR STRUCTURE THAT HOLDS START OF SPIN DATA SOURCE INFO."); break; case START_SPIN_TIME_MALLOC: strcpy (e_str, "IR_ALLOC_SPIN_SWEEP_TIMES: NO MEMORY FOR TIME OF SAMPLE VALUES FOR SPIN DETERMINATION."); break; case POT_BAD_TIMES: strcpy (e_str, "IR_IDFS_POTENTIAL_VALUES: THE END TIME OF THE SAMPLE IS LESS THAN THE START TIME."); break; case CUR_TIME_NOT_FOUND: strcpy (e_str, "IR_GET_CURRENT_TIME: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case CP_MAIN_DATA_MISSING: strcpy (e_str, "IR_CELESTIAL_POSITION_SOURCE_STATUS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case EULER_BAD_TIMES: strcpy (e_str, "IR_IDFS_EULER_ANGLES: THE END TIME OF THE SAMPLE IS LESS THAN THE START TIME."); break; case CP_BAD_FRAC: strcpy (e_str, "IR_PROCESS_CELESTIAL_POSITION_DATA: INVALID NORMALIZATION FACTOR CALCULATED FOR CELESTIAL POSITION ANGLE DATA."); break; case CP_BAD_TIMES: strcpy (e_str, "IR_IDFS_CELESTIAL_POSITION_ANGLES: THE END TIME OF THE SAMPLE IS LESS THAN THE START TIME."); break; case SPIN_SRC_MAIN_DATA_MISSING: strcpy (e_str, "IR_START_SPIN_SOURCE_STATUS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case CHK_TDATA_NOT_FOUND: strcpy (e_str, "IR_CHECK_TENSOR_DATA_MEMORY: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case FIRST_SEN_NOT_FOUND: strcpy (e_str, "FIRST_IDFS_SENSOR: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case START_ELE_BAD_SENSOR: strcpy (e_str, "IR_START_ELEMENT_OF_SPIN: THE VALUE FOR THE SENSOR ARGUMENT IS INVALID."); break; case START_ELE_SPIN_NO_SENSOR: strcpy (e_str, "IR_START_ELEMENT_OF_SPIN: THE SENSOR BEING REQUESTED WAS NOT PROCESSED."); break; case READ_SPIN_ALL_REALLOC: strcpy (e_str, "IR_CREATE_SPIN_DATA_STRUCTURE: NO MEMORY FOR REALLOCATION OF ARRAY OF POINTERS FOR IDF_DATA STRUCTURES."); break; case READ_SPIN_NOT_FOUND: strcpy (e_str, "READ_DREC_SPIN: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case READ_SPIN_NO_START: strcpy (e_str, "READ_DREC_SPIN: THE ROUTINE START_OF_SPIN HAS NOT BEEN CALLED."); break; case READ_SPIN_SENSOR_NOT_FOUND: strcpy (e_str, "READ_DREC_SPIN: THE EX_INFO STRUCTURE FOR ONE OF THE SENSORS BEING PROCESSED HAS NEVER BEEN ALLOCATED."); break; case READ_SPIN_PARTIAL: strcpy (e_str, "READ_DREC_SPIN: A COMPLETE SPIN IS NOT POSSIBLE SINCE THE NEXT SET OF DATA FILES ARE NOT AVAILABLE ."); break; case ONCE_BAD_HEADER_FMT: strcpy (e_str, "IR_READ_IDF_ONCE: INVALID HEADER RECORD FORMAT VALUE."); break; case ONCE_BAD_TENSOR_RANK: strcpy (e_str, "IR_READ_IDF_ONCE: INVALID RANK VALUE FOR TENSOR DATA."); break; case ONCE_BAD_TENSOR_LENGTHS: strcpy (e_str, "IR_READ_IDF_ONCE: INVALID DIMENSION LENGTH VALUE FOR TENSOR DATA."); break; case ONCE_CTARGET_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR CAL. SET TARGET VALUES."); break; case ONCE_CLEN_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR CAL. SET WORD LENGTHS."); break; case ONCE_CSCOPE_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR CAL. SET SCOPE."); break; case ONCE_CDTYPE_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR CAL. SET D_TYPE FLAGS."); break; case CAL_DATA_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR CAL DATA INFORMATION."); break; case ONCE_DATA_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR DATA RECORD INFORMATION."); break; case ONCE_D_TYPE_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR D_TYPE FOR EACH SENSOR."); break; case ONCE_TDW_LEN_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR TDW_LEN FOR EACH SENSOR."); break; case ONCE_TBL_INFO_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR INST_TBL_INFO STRUCTURES."); break; case ONCE_SPIN_OFF_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR START OF SPIN TIME OFFSET FLAGS."); break; case ONCE_SEN_STAT_MALLOC: strcpy (e_str, "IR_READ_IDF_ONCE: NO MEMORY FOR SENSOR STATUS FLAGS."); break; case ONCE_BAD_NUM_TBLS: strcpy (e_str, "IR_READ_IDF_ONCE: NUM_TBLS CANNOT BE SET TO ANY VALUE OTHER THAN ZERO FOR TENSOR DATA."); break; case ONCE_BAD_MAX_NSS: strcpy (e_str, "IR_READ_IDF_ONCE: MAX_NSS CANNOT BE SET TO ANY VALUE OTHER THAN 1 FOR TENSOR DATA."); break; case ONCE_BAD_SMP_ID: strcpy (e_str, "IR_READ_IDF_ONCE: SMP_ID MUST BE SET TO 3 FOR TENSOR DATA."); break; case ONCE_BAD_DA_METHOD: strcpy (e_str, "IR_READ_IDF_ONCE: DA_METHOD MUST BE SET TO ZERO FOR TENSOR DATA."); break; case ONCE_BAD_SWP_LEN: strcpy (e_str, "IR_READ_IDF_ONCE: SWP_LEN MUST BE SET TO 1 FOR TENSOR DATA."); break; case ONCE_BAD_SEN_MODE: strcpy (e_str, "IR_READ_IDF_ONCE: SEN_MODE MUST BE SET TO EITHER 3 OR 7 FOR TENSOR DATA."); break; case ONCE_BAD_CAL_TARGET: strcpy (e_str, "IR_READ_IDF_ONCE: CAL_TARGET CANNOT BE SET TO ANY VALUE OTHER THAN ZERO FOR TENSOR DATA."); break; case ONCE_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_READ_IDF_ONCE: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case ONCE_IDF_MANY_BYTES: strcpy (e_str, "IR_READ_IDF_ONCE: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case ONCE_IDF_TBL_NUM: strcpy (e_str, "IR_READ_IDF_ONCE: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case ONCE_IDF_CON_NUM: strcpy (e_str, "IR_READ_IDF_ONCE: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case ONCE_IDF_NO_ENTRY: strcpy (e_str, "IR_READ_IDF_ONCE: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case DESTROY_NO_IDF_DATA: strcpy (e_str, "DESTROY_LAST_IDF_DATA_STRUCTURE: THERE ARE NO IDF DATA STRUCTURES TO BE FREED."); break; case DESTROY_NO_TENSOR_DATA: strcpy (e_str, "DESTROY_LAST_TENSOR_DATA_STRUCTURE: THERE ARE NO TENSOR DATA STRUCTURES TO BE FREED."); break; case BKGD_MAIN_DATA_MISSING: strcpy (e_str, "IR_BACKGROUND_SOURCE_STATUS: THE EX_INFO STRUCTURE BEING REQUESTED HAS NEVER BEEN ALLOCATED."); break; case BKGD_BAD_SRC: strcpy (e_str, "IR_GET_BACKGROUND_INFO: THE BACKGROUND DATA SOURCE IS NON-SCALAR."); break; case BAD_BKGD_FORMAT: strcpy (e_str, "IR_GET_BACKGROUND_INFO: THE FORMAT SPECIFICATION FOR THE BACKGROUND DATA IS INVALID."); break; case BKGD_TBL_MALLOC: strcpy (e_str, "IR_BACKGROUND_TBL_INFO: NO MEMORY FOR TABLE APPLICATION INFORMATION."); break; case BKGD_MALLOC: strcpy (e_str, "IR_ALLOC_BACKGROUND_INFO : NO MEMORY HAS BEEN ALLOCATED FOR BACKGROUND STRUCTURE."); break; case BKGD_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_BACKGROUND_INFO: NO MEMORY FOR CONSTANT / DYNAMIC SENSOR VALUES."); break; case BKGD_IDF_DATA_MALLOC: strcpy (e_str, "IR_ALLOC_BACKGROUND_INFO: NO MEMORY FOR ARRAY OF POINTERS FOR IDF_DATA STRUCTURES."); break; case BKGD_INFO_IDF_ELE_NOT_FOUND: strcpy (e_str, "IR_GET_BACKGROUND_INFO: VALUE BEING REQUESTED WAS NOT FOUND IN THE VIDF FILE."); break; case BKGD_INFO_IDF_MANY_BYTES: strcpy (e_str, "IR_GET_BACKGROUND_INFO: NUMBER OF ELEMENTS BEING REQUESTED IS TOO LARGE FOR DATA FIELD."); break; case BKGD_INFO_IDF_TBL_NUM: strcpy (e_str, "IR_GET_BACKGROUND_INFO: THE TABLE NUMBER BEING REQUESTED IS LARGER THAN THE NUMBER OF TABLES."); break; case BKGD_INFO_IDF_CON_NUM: strcpy (e_str, "IR_GET_BACKGROUND_INFO: THE CONSTANT BEING REQUESTED EXCEEDS THE NUMBER OF DEFINED CONSTANTS."); break; case BKGD_INFO_IDF_NO_ENTRY: strcpy (e_str, "IR_GET_BACKGROUND_INFO: THE FIELD BEING REQUESTED IS NOT DEFINED."); break; case BKGD_BAD_TIMES: strcpy (e_str, "IR_IDFS_BACKGROUND_VALUES: THE END TIME OF THE SAMPLE IS LESS THAN THE START TIME."); break; case BKGD_BAD_FRAC: strcpy (e_str, "IR_PROCESS_BACKGROUND_DATA: INVALID NORMALIZATION FACTOR CALCULATED FOR BACKGROUND DATA."); break; case NO_BKGD_CONSTANT: strcpy (e_str, "IR_GET_BACKGROUND_CONSTANTS: THE BACKGROUND CONSTANTS ARE NOT DEFINED IN THE VIDF FILE."); break; } }