#ident "@(#) ReadNewVIDF.C 1.18 05/08/19 SwRI" #include /* for NULL */ #include /* for calloc/free */ #include /* for memset */ #include "vidf_defs.h" #include "SDDAS_types.h" #include "vidf_codes.h" #include "vidf_local.h" #include "Cache.h" static CacheType *_Cache; /***************************************************************************** * * * ReadNewVIDF SUBROUTINE * * * * DESCRIPTION * * This routine is called to retrieve information from the VIDF definition* * file for the data set specified. The information is either retrieved * * from the VIDF definition file on disk (slow method) or from the memory * * that was allocated to hold the VIDF data (fast method). If an error * * condition was encountered when setting up the fast method, conditions * * are reset to indicate slow access if the user wishes to ignore the error * * code returned. * * * * INPUT VARIABLES * * SDDAS_CHAR *var output value(s) associated with selected * * field * * VIDF_DEFS what specified field in VIDF file * * SDDAS_SHORT which the table or constant definition from * * which the required field is to be retrieved* * SDDAS_SHORT len if the selected field is an array, this is * * the whichber of elements to be returned * * SDDAS_LONG start if the selected field is an array, this is * * the starting position in the array * * * * USAGE * * x = ReadNewVIDF (&var, quan, which, start, len) * * * * * ****************************************************************************/ void CreateCache () { if (_Cache == NULL) _Cache = new CacheType; } void ClearCache () { delete _Cache; _Cache = NULL; } int HandleTIME_OFF (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_SHORT num_sen; short sensors; int i, index = 0; int ret_val = 1; SDDAS_LONG *lptr = (SDDAS_LONG *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_sen, _SEN, 0); i = start; if (len != -1) { sensors = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (sensors > num_sen) sensors = num_sen; } else sensors = num_sen; while ((ret_val == 1) && (i < sensors)) { GetFromNewVIDF (pVIDF, (void *) &(lptr [index]), _TIME_OFF, i); i++; index++; } return (ret_val); } int HandleSPIN_TIME_OFF (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_SHORT num_sen; short sensors; int i, index = 0; int ret_val = 1; SDDAS_LONG *lptr = (SDDAS_LONG *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_sen, _SEN, 0); i = start; if (len != -1) { sensors = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (sensors > num_sen) sensors = num_sen; } else sensors = num_sen; /* This is a new field which does not necessarily have to be defined */ /* by each sensor. If it is not defined, set to zero. */ while ((ret_val == 1) && (i < sensors)) { ret_val = GetFromNewVIDF (pVIDF, (void *) &(lptr [index]), _SPIN_TIME_OFF, i); if (ret_val == VIDF_ELEMENT_NOT_FOUND) { ret_val = 1; lptr[index] = 0; } i++; index++; } return (ret_val); } int HandleSEN_STATUS (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_SHORT num_sen; short sensors; int i, index = 0; int ret_val = 1; SDDAS_CHAR *cptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_sen, _SEN, 0); i = start; if (len != -1) { sensors = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (sensors > num_sen) sensors = num_sen; } else sensors = num_sen; while ((ret_val == 1) && (i < sensors)) { GetFromNewVIDF (pVIDF, (void *) &(cptr [index]), _SEN_STATUS, i); i++; index++; } return (ret_val); } int HandleD_TYPE (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_SHORT num_sen; short sensors; int i, index = 0; int ret_val = 1; SDDAS_CHAR *cptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_sen, _SEN, 0); i = start; if (len != -1) { sensors = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (sensors > num_sen) sensors = num_sen; } else sensors = num_sen; while ((ret_val == 1) && (i < sensors)) { GetFromNewVIDF (pVIDF, (void *) &(cptr [index]), _D_TYPE, i); i++; index++; } return (ret_val); } int HandleTDW_LEN (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_SHORT num_sen; short sensors; int i, index = 0; int ret_val = 1; SDDAS_CHAR *cptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_sen, _SEN, 0); i = start; if (len != -1) { sensors = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (sensors > num_sen) sensors = num_sen; } else sensors = num_sen; while ((ret_val == 1) && (i < sensors)) { GetFromNewVIDF (pVIDF, (void *) &(cptr [index]), _TDW_LEN, i); i++; index++; } return (ret_val); } int HandleSTATES (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char states; int i; int ret_val = 1; SDDAS_SHORT *sptr = (SDDAS_SHORT *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &states, _STATUS, 0); if (len == -1) len = states; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > states) len = states - start; i = 0; while ((ret_val == 1) && (i < len)) { ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [i]), _STATE, i + start); i++; } return (ret_val); } int HandleCAL_USE (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char num_cals, num_csets; int i, index = 0; int ret_val = 1; SDDAS_SHORT *sptr = (SDDAS_SHORT *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_csets, _CAL_SETS, 0); i = start; if (len != -1) { num_cals = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (num_cals > num_csets) num_cals = num_csets; } else num_cals = num_csets; while ((ret_val == 1) && (i < num_cals)) { ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [index]), _CAL_USE, i); i++; index++; } return (ret_val); } int HandleCAL_WLEN (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char num_cals, num_csets; int i, index = 0; int ret_val = 1; SDDAS_CHAR *sptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_csets, _CAL_SETS, 0); i = start; if (len != -1) { num_cals = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (num_cals > num_csets) num_cals = num_csets; } else num_cals = num_csets; while ((ret_val == 1) && (i < num_cals)) { ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [index]), _CAL_WLEN, i); i++; index++; } return (ret_val); } int HandleCAL_TARGET (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char num_cals, num_csets; int i, index = 0; int ret_val = 1; SDDAS_CHAR *sptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_csets, _CAL_SETS, 0); i = start; if (len != -1) { num_cals = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (num_cals > num_csets) num_cals = num_csets; } else num_cals = num_csets; while ((ret_val == 1) && (i < num_cals)) { ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [index]), _CAL_TARGET, i); i++; index++; } return (ret_val); } int HandleCAL_SCOPE (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char num_cals, num_csets; int i, index = 0; int ret_val = 1; SDDAS_CHAR *sptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_csets, _CAL_SETS, 0); i = start; if (len != -1) { num_cals = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (num_cals > num_csets) num_cals = num_csets; } else num_cals = num_csets; /* This is a new field which does not necessarily have to be defined */ /* by each cal set. If it is not defined, set to old scheme. */ while ((ret_val == 1) && (i < num_cals)) { ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [index]), _CAL_SCOPE, i); if (ret_val == VIDF_ELEMENT_NOT_FOUND) { ret_val = 1; sptr[index] = 0; /* default back to when each sensor defines the cal set */ } i++; index++; } return (ret_val); } int HandleCAL_D_TYPE (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char num_cals, num_csets; int i, index = 0; int ret_val = 1; SDDAS_CHAR *cptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_csets, _CAL_SETS, 0); i = start; if (len != -1) { num_cals = i + len; /* If the user asked for too many items, based upon starting */ /* location, then just give them up to the maximum limit. */ if (num_cals > num_csets) num_cals = num_csets; } else num_cals = num_csets; /* This is a new field which does not necessarily have to be defined */ /* by each cal set. If it is not defined, set to old scheme. */ while ((ret_val == 1) && (i < num_cals)) { ret_val = GetFromNewVIDF (pVIDF, (void *) &(cptr [index]), _CAL_D_TYPE, i); if (ret_val == VIDF_ELEMENT_NOT_FOUND) { ret_val = 1; cptr[index] = 0; /* default back to when hard-coded d_type for cal. */ } i++; index++; } return (ret_val); } int HandlePA_BXBYBZ (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { int ret_val = 1; SDDAS_SHORT *sptr = (SDDAS_SHORT *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [0]), _PA_BX, 0); if (ret_val == ALL_OKAY) ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [1]), _PA_BY, 0); if (ret_val == ALL_OKAY) ret_val = GetFromNewVIDF (pVIDF, (void *) &(sptr [2]), _PA_BZ, 0); return (ret_val); } int HandleCRIT_STATUS (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { short num_sen; int i, j; int ret_val = 1; SDDAS_CHAR *cptr; SDDAS_CHAR *ret_ptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_sen, _SEN, 0); cptr = (SDDAS_CHAR *) calloc (num_sen, sizeof (SDDAS_CHAR)); ret_val = GetFromNewVIDF (pVIDF, (void *) cptr, _CRIT_STATUS, which); if ((len == -1) || (len > num_sen)) len = num_sen; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num_sen) len = num_sen - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = cptr [j]; } free (cptr); return (ret_val); } int HandleCRIT_OFF (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { short num_sen; int i, j; int ret_val = 1; SDDAS_SHORT *sptr; SDDAS_SHORT *ret_ptr = (SDDAS_SHORT *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_sen, _SEN, 0); sptr = (SDDAS_SHORT *)calloc (num_sen, sizeof (SDDAS_SHORT)); ret_val = GetFromNewVIDF (pVIDF, (void *) sptr, _CRIT_OFF, which); if ((len == -1) || (len > num_sen)) len = num_sen; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num_sen) len = num_sen - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = sptr [j]; } free (sptr); return (ret_val); } int HandleCRIT_ACTION (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_INT num_ele; int i, j; int ret_val = 1; SDDAS_LONG *lptr; SDDAS_LONG *ret_ptr = (SDDAS_LONG *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num_ele, _CRIT_ACT_SZ, which); lptr = (SDDAS_LONG *) calloc (num_ele, sizeof (SDDAS_LONG)); ret_val = GetFromNewVIDF (pVIDF, (void *) lptr, _CRIT_ACTION, which); if ((len == -1) || (len > num_ele)) len = num_ele; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num_ele) len = num_ele - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = lptr [j]; } free (lptr); return (ret_val); } int HandleTBL_FMT (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char num_status; short num; char tbl_var; int i, j; int ret_val = 1; SDDAS_CHAR *cptr; SDDAS_CHAR *ret_ptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &tbl_var, _TBL_VAR, which); if (tbl_var == 4 || tbl_var == 5) { ret_val = GetFromNewVIDF (pVIDF, (void *) &num_status, _STATUS, 0); num = (short) num_status; } else ret_val = GetFromNewVIDF (pVIDF, (void *) &num, _SEN, 0); cptr = (SDDAS_CHAR *) calloc (num, sizeof (SDDAS_CHAR)); ret_val = GetFromNewVIDF (pVIDF, (void *) cptr, _TBL_FMT, which); if ((len == -1) || (len > num)) len = num; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num) len = num - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = cptr [j]; } free (cptr); return (ret_val); } int HandleTBL_OFF (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { char num_status; short num; char tbl_var; int i, j; int ret_val = 1; SDDAS_LONG *lptr; SDDAS_LONG *ret_ptr = (SDDAS_LONG *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &tbl_var, _TBL_VAR, which); if (tbl_var == 4 || tbl_var == 5) { ret_val = GetFromNewVIDF (pVIDF, (void *) &num_status, _STATUS, 0); num = (short) num_status; } else ret_val = GetFromNewVIDF (pVIDF, (void *) &num, _SEN, 0); lptr = (SDDAS_LONG *) calloc (num, sizeof (SDDAS_LONG)); ret_val = GetFromNewVIDF (pVIDF, (void *) lptr, _TBL_OFF, which); if ((len == -1) || (len > num)) len = num; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num) len = num - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = lptr [j]; } free (lptr); return (ret_val); } int HandleTBL_SCA (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_INT num; int i, j; int ret_val = 1; SDDAS_CHAR *cptr; SDDAS_CHAR *ret_ptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num, _TBL_SCA_SZ, which); num = abs (num); if (num != 0) { cptr = (SDDAS_CHAR *) calloc (num, sizeof (SDDAS_CHAR)); ret_val = GetFromNewVIDF (pVIDF, (void *) cptr, _TBL_SCA, which); if ((len == -1) || (len > num)) len = num; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num) len = num - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = cptr [j]; } free (cptr); } return (ret_val); } int HandleTBL (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { SDDAS_INT num; int i, j; int ret_val = 1; void *values; SDDAS_INT *iptr; SDDAS_CHAR tbl_type; SDDAS_INT *ret_ptr = (SDDAS_INT *) var; if ((values = _Cache->GetFromCache (pVIDF, _TBL, which)) == NULL) { ret_val = GetFromNewVIDF (pVIDF, (void *) &num, _TBL_ELE_SZ, which); ret_val = GetFromNewVIDF (pVIDF, (void *) &tbl_type, _TBL_TYPE, which); if (tbl_type == 1) { values = calloc (num, sizeof (SDDAS_CHAR *)); } else { values = calloc (num, sizeof (SDDAS_INT)); } ret_val = GetFromNewVIDF (pVIDF, values, _TBL, which); _Cache->AddToCache (pVIDF, _TBL, which, values, true); _Cache->AddToCache (pVIDF, _TBL_ELE_SZ, which, reinterpret_cast (num), false); _Cache->AddToCache (pVIDF, _TBL_TYPE, which, (void *) (long) tbl_type, false); } else { /* This double typecasting is needed for the AMD_64 platform */ /* On other platforms, it should not make a difference */ num = (SDDAS_INT) ((long) _Cache->GetFromCache (pVIDF, _TBL_ELE_SZ, which)); tbl_type = (SDDAS_CHAR) ((long) _Cache->GetFromCache (pVIDF, _TBL_TYPE, which)); } if ((len == -1) || (len > num)) len = num; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num) len = num - start; if (tbl_type == 1) { /* some sort of string table */ SDDAS_CHAR **str_ret_ptr = (SDDAS_CHAR **) var; for (i = 0, j = start; i < len; i++, j++) { str_ret_ptr [i] = reinterpret_cast (values) [j]; } } else { iptr = (SDDAS_INT *) values; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = iptr [j]; } } return (ret_val); } int HandleCONST_SCA (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { short num; int i, j; int ret_val = 1; SDDAS_CHAR *cptr; SDDAS_CHAR *ret_ptr = (SDDAS_CHAR *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num, _SEN, which); cptr = (SDDAS_CHAR *) calloc (num, sizeof (SDDAS_CHAR)); ret_val = GetFromNewVIDF (pVIDF, (void *) cptr, _CONST_SCA, which); if ((len == -1) || (len > num)) len = num; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num) len = num - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = cptr [j]; } free (cptr); return (ret_val); } int HandleCONST (void *pVIDF, void *var, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { short num; int i, j; int ret_val = 1; SDDAS_LONG *lptr; SDDAS_LONG *ret_ptr = (SDDAS_LONG *) var; ret_val = GetFromNewVIDF (pVIDF, (void *) &num, _SEN, which); lptr = (SDDAS_LONG *) calloc (num, sizeof (SDDAS_LONG)); ret_val = GetFromNewVIDF (pVIDF, (void *) lptr, _VIDF_CONST, which); if ((len == -1) || (len > num)) len = num; /* If the number of elements needed based upon the start location */ /* will exceed the number of values defined, adjust the number of */ /* elements needed. */ if ((len + start) > num) len = num - start; for (i = 0, j = start; i < len; i++, j++) { ret_ptr [i] = lptr [j]; } free (lptr); return (ret_val); } int ReadNewVIDF (void *pVIDF, void *var, VIDF_DEFS what, SDDAS_SHORT which, SDDAS_LONG start, SDDAS_SHORT len) { int ret_val = ALL_OKAY; short tmp_short; char *sptrs[1]; switch (what) { case _NUM_COMNTS : *(char *) var = (SDDAS_CHAR) 0; break; case _COMMENTS : var = NULL; break; case _PA_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, &tmp_short, _PA_FORMAT, which)) != ALL_OKAY) *(char *) var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; case _PMI_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, &tmp_short, _PMI_FORMAT, which)) != ALL_OKAY) *(char *) var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; case _CP_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, &tmp_short, _CP_FORMAT, which)) != ALL_OKAY) *(char *) var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; case _POT_SRC_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, &tmp_short, _POT_SRC_FORMAT, which)) != ALL_OKAY) *(char *) var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; case _BKGD_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, &tmp_short, _BKGD_FORMAT, which)) != ALL_OKAY) *(char *) var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; case _START_SPIN_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, &sptrs[0], _START_SPIN_PROJECT, which)) != ALL_OKAY) *(char *) var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; case _COORD_SYSTEM_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, &sptrs[0], _COORD_SYSTEM, which)) != ALL_OKAY) { /* Is PMI defined? */ if ((ret_val = GetFromNewVIDF (pVIDF, &tmp_short, _PMI_FORMAT, which)) != ALL_OKAY) { /* Is Celestial Position defined? */ if ((ret_val = GetFromNewVIDF (pVIDF, &tmp_short, _CP_FORMAT, which)) != ALL_OKAY) *(char *) var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; } else *(char *) var = (SDDAS_CHAR) 1; } else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; /* fill_flag is now part of the converter so we don't need to handle it case _FILL_FLG : if ((ret_val = GetFromNewVIDF (pVIDF, var, _FILL, which)) != ALL_OKAY) *(char *)var = (SDDAS_CHAR) 0; else *(char *) var = (SDDAS_CHAR) 1; ret_val = ALL_OKAY; break; */ case _TBL_DESC_LEN : memset ((SDDAS_SHORT *) var, 0, sizeof (SDDAS_SHORT)); break; case _CONST_DESC_LEN : memset ((SDDAS_SHORT *) var, 0, sizeof (SDDAS_SHORT)); break; case _TIME_OFF : HandleTIME_OFF (pVIDF, var, which, start, len); break; case _SPIN_TIME_OFF : HandleSPIN_TIME_OFF (pVIDF, var, which, start, len); break; case _SEN_STATUS : HandleSEN_STATUS (pVIDF, var, which, start, len); break; case _D_TYPE : HandleD_TYPE (pVIDF, var, which, start, len); break; case _TDW_LEN : HandleTDW_LEN (pVIDF, var, which, start, len); break; case _STATES : HandleSTATES (pVIDF, var, which, start, len); break; case _PA_BXBYBZ : HandlePA_BXBYBZ (pVIDF, var, which, start, len); break; case _CAL_USE : HandleCAL_USE (pVIDF, var, which, start, len); break; case _CAL_WLEN : HandleCAL_WLEN (pVIDF, var, which, start, len); break; case _CAL_TARGET : HandleCAL_TARGET (pVIDF, var, which, start, len); break; case _CAL_SCOPE : HandleCAL_SCOPE (pVIDF, var, which, start, len); break; case _CAL_D_TYPE : HandleCAL_D_TYPE (pVIDF, var, which, start, len); break; case _CRIT_STATUS : HandleCRIT_STATUS (pVIDF, var, which, start, len); break; case _CRIT_OFF : HandleCRIT_OFF (pVIDF, var, which, start, len); break; case _CRIT_ACTION : HandleCRIT_ACTION (pVIDF, var, which, start, len); break; case _TBL_FMT : HandleTBL_FMT (pVIDF, var, which, start, len); break; case _TBL_OFF : HandleTBL_OFF (pVIDF, var, which, start, len); break; case _TBL_SCA : HandleTBL_SCA (pVIDF, var, which, start, len); break; case _TBL : HandleTBL (pVIDF, var, which, start, len); break; case _CONST_SCA : HandleCONST_SCA (pVIDF, var, which, start, len); break; case _VIDF_CONST : HandleCONST (pVIDF, var, which, start, len); break; case _DATA_LAT_UNITS : case _SWP_RESET_UNITS : case _SEN_RESET_UNITS : if ((ret_val = GetFromNewVIDF (pVIDF, var, what, which)) != ALL_OKAY) { *(char *)var = (SDDAS_CHAR) -6; ret_val = ALL_OKAY; } break; case _NANO_DEFINED : if ((ret_val = GetFromNewVIDF (pVIDF, var, what, which)) != ALL_OKAY) { *(char *)var = (SDDAS_CHAR) 0; ret_val = ALL_OKAY; } break; case _ORBITING_BODY : if ((ret_val = GetFromNewVIDF (pVIDF, var, what, which)) != ALL_OKAY) { *(SDDAS_SHORT *)var = (SDDAS_SHORT) 0; ret_val = ALL_OKAY; } break; case _REF_SEN_DELAY : if ((ret_val = GetFromNewVIDF (pVIDF, var, what, which)) != ALL_OKAY) { *(SDDAS_FLOAT *)var = (SDDAS_FLOAT) 0.0; ret_val = ALL_OKAY; } break; case _REF_SEN_DELAY_UNIT : if ((ret_val = GetFromNewVIDF (pVIDF, var, what, which)) != ALL_OKAY) { *(SDDAS_SHORT *)var = (SDDAS_SHORT) 1; ret_val = ALL_OKAY; } break; case _MAX_PACKING: if ((ret_val = GetFromNewVIDF (pVIDF, var, what, which)) != ALL_OKAY) { *(SDDAS_SHORT *)var = (SDDAS_SHORT) 1; /* no packing - 1 scalar */ ret_val = ALL_OKAY; } break; case _HEADER_FORMAT : if ((ret_val = GetFromNewVIDF (pVIDF, var, what, which)) != ALL_OKAY) { *(char *)var = (SDDAS_CHAR) 1; /* original header definition */ ret_val = ALL_OKAY; } break; default : ret_val = GetFromNewVIDF (pVIDF, var, what, which); } return (ret_val); }